data/user-guide-final.md

# GeoDisaster 2,921 — final user guide

Specification date: 2026-10-15. Coverage: **43 of 43 question types**.

This is the authoritative public specification for the benchmark. It explains
the dataset, runtime contract, evaluation policy, release procedure, and all
43 question types as they are defined in the published version.

## 1. Benchmark purpose

GeoDisaster tests whether an agent can select and execute the correct tools,
pass artifacts causally between them, combine heterogeneous geospatial
sources, and produce a schema-valid answer. Upstream data acquisition is done
during dataset construction. The cached rasters, vectors, tables, metadata,
and imagery are intentional benchmark inputs: they make training and
evaluation fast, deterministic, reproducible, and independent of live API
availability, authentication, quotas, and later source changes.

The benchmark measures **multi-source geospatial reasoning and tool use**.
For fast, repeatable execution, its inputs are downloaded and cached. The
worker contracts also allow compatible new sources and scenarios to be
registered and processed through the same agent workflow.

## 2. Authoritative dataset and evaluation contract

- Canonical file:
  `data/core/geodisaster_2921_source_with_splits.jsonl`
- Canonical SHA-256:
  `03988b960e6b09ae01fb622fe45b35d763eb705485cddc3cea68bcac7ae63fe1`
- Inventory: 2,921 records, 43 logical question types, 2,629 train and 292
  public-reference test records.
- Split isolation: no shared sample group, declared path, normalized
  routing-content group, or exact complete model-visible trajectory between
  train and test.
- Agent-visible test file: `data/core/geodisaster_2921_test_inputs.jsonl`.
  It omits expected answers, GT chains, and internal build/replay provenance.
- The test set is public reference gold, not a secret leaderboard. A fair
  agent run mounts only the isolated agent-visible inputs, not reference or
  teacher files.
- Final answers are complete JSON values scored under
  `geodisaster_structured_answer_v2`: exact object keys, types, strings,
  booleans, null states, array lengths/order, and finite numeric values.
  Numeric leaves use absolute tolerance `1e-6`; relative tolerance is disabled
  so accepted error does not grow with value magnitude.
  Finding the right number in the wrong field is not correct.
- `data/core/scoring_policy_43.json` is the executable scoring authority. The
  nested `correction_provenance.publication_contract.structured_scoring_policy`
  value retained in canonical records names the historical publication pass
  that produced those records; it does not select or override the active v2
  evaluator. Values under `correction_provenance.evidence` are opaque build-run
  labels, not runtime filesystem paths or agent-visible inputs.

## 3. How an agent solves a record

1. The evaluator creates a sanitized session and exposes the question plus
   named initial handles. The agent does not receive evaluator gold.
2. `ReadData` opens a declared input handle and returns a scene handle.
   Unsupported roles, times, options, or missing required paths fail.
3. `PrepareScene` validates compatible scene handles and creates a work
   handle. It is orchestration, not an undeclared data fetch.
4. Analytical workers consume the current handle and emit new result/artifact
   handles. A later analytical step consumes the preceding result when the
   GT chain declares a causal dependency.
5. After each successful tool call, the runtime attempts the declared
   schema-specific projection from worker evidence. It publishes
   `ANSWER_JSON:answer_1` only when the complete projection validates.
6. `TaskComplete` closes a specialist subgoal; it does not contain the final
   answer. Multi-agent ORC finishes with `Terminate(answer_ref=...)`, while the
   single agent finishes with `FinalAnswer(answer_ref=...)`. The runtime then
   resolves and revalidates the referenced JSON for scoring.

The same worker contracts support both published agent forms. In the
single-agent conversations, one agent plans, calls the workers, and answers.
In the multi-agent conversations, ORC plans, delegates each analytical step
to its declared specialist, receives the resulting handles/evidence, and
terminates with the published answer reference. ORC does not replace or
silently rerun a specialist computation or generate the resolved JSON.

| Multi-agent owner | Workers | Responsibility |
|---|---|---|
| GA | `ReadData`, `PrepareScene`, `MeasureArea`, `ExtractObjects`, `MapFlood`, `RenderMap` | Open declared inputs, establish geospatial lineage, create or measure spatial artifacts, and render requested images. |
| PA | `ComputeStats`, `CompareSources`, `DetectChange`, `ClassifyChange`, `ScoreHazard`, `EstimateExposure`, `RankRegions`, `PlanRoutes`, `CompareRoutes` | Perform quantitative analysis, comparison, classification, exposure/ranking, and routing decisions. |
| VRA | `AssessDamage`, `DescribeFlood`, `CompareScenes` | Interpret damage/flood evidence and compare scene-level results. |

Each question-type section below gives the exact subset, argument contract,
handle handoff, calculation, and answer fields used for that task. A tool is
not a generic answer lookup: it validates its declared arguments and consumes
only the opened lineage required by that question.

Every runtime read is restricted to the exact repository-relative paths in
the opened handle lineage. Hidden answers, ground truth, trajectories, and
undeclared sibling files are denied. Null can be a valid schema value; a tool
error, missing required input, non-finite required result, failed specialist
contract, or unavailable terminal answer reference is not a valid empty answer.

## 4. Data, provenance, and release policy

All source paths are repository-relative. The canonical file contains 14,963
path references representing 5,681 unique paths. In the complete development
snapshot, deep inspection resolved the declared paths and opened all 10,831
source files with zero empty files or read failures. The public thin package
intentionally omits the Sen1Floods11 payload; run the checksum-verified
hydrator described in `ATTRIBUTIONS.md` before executing those 500 records.
For those records, an artifact card's `exists: true` states the hydrated
execution contract, not that the separately distributed thin archive already
contains the file. Thin-mode audit permits only the exact 200 upstream-derived
paths named by the pinned manifest; hydration materializes and verifies them.

The package is mixed-license. `ATTRIBUTIONS.md` is the authoritative mapping
from every packaged file family to its upstream product, citation, terms, and
transformation. Project-authored questions, schemas, and chains do not
relicense upstream imagery or data. The public release excludes the retained
Sen1Floods11 payload and supplies a checksum-verified upstream hydrator.

## 5. Final validation baseline

- 2,921/2,921 prescribed chains executed successfully in the complete,
  hydrated development snapshot.
- 2,921/2,921 records passed field-aware substantive validation.
- 43/43 logical types are fully correct under their declared contracts.
- The same 2,921/2,921 result reproduces in the hash-locked Python 3.10.12
  replay environment with zero dependency or compatibility warnings.
- A gold-free filesystem bundle containing only the 573 declared test files
  passes 292/292 reference-test records across all 43 types, with zero
  undeclared-path authorization violations.
- Core projections and all multi-agent, single-agent, turn-level, and
  role-SFT exports have zero drift from the canonical source.
- Invalid cross-family and causal-input mutations were rejected in 43/43
  tests.
- All 816 declared public question JSON sidecars are valid and contain no
  private AOI-type hints, GT paths, or final answers. An expected-answer shape
  describes required output fields and types; it is not answer gold.
- Generated artifacts used by the published chains are nonempty.

The following sections specify each question type separately, including its
question, declared files, worker arguments, causal sequence, calculation,
output schema, edge cases, and verified population. Every type also states:

- **what the agent must do** — the observable actions and final response;
- **what the agent must infer** — the conclusion that must be derived from
  worker evidence rather than copied from an input; and
- **what the task measures** — why that question belongs in an agentic
  geospatial benchmark.

## 6. Dataset construction, split, and answer registry

The canonical JSONL is the sole authority. Core train/test files, public test
inputs, multi-agent and single-agent conversations, turn rows, and role-SFT
rows are generated projections rather than independent datasets. Their IDs,
splits, chains, answers, handles, and weights match the canonical source and
the declared worker contract.

The public multi-agent role-SFT projections are stored only in
`data/multi_agent/sft_train/` and `data/multi_agent/sft_test/`. Every published
conversation and SFT row carries `id`, `sample_id`, and `question_type` so it
can be joined directly to the canonical record. Source inputs remain
repository-relative. Non-distributed replay products referenced by teacher
evidence use `generated-artifact://` logical locators rather than build-host
filesystem paths.

| Released projection | Train rows | Test/eval rows |
|---|---:|---:|
| Core tasks | 2,629 | 292 |
| Full multi-agent episodes | 2,629 | 292 |
| Full single-agent episodes | 2,629 | 292 |
| Multi-agent ORC SFT turns | 11,895 | 1,318 |
| Multi-agent GA SFT turns | 11,127 | 1,235 |
| Multi-agent PA SFT turns | 5,899 | 656 |
| Multi-agent VRA SFT turns | 2,763 | 302 |
| Single-agent SFT turns | 18,410 | 2,043 |

The role and single-agent turn projections contain 55,648 SFT rows in total.
Single-agent training uses SFT plus deterministic/live evaluation. GRPO/RCEA is
defined only for the four-role multi-agent system and does not require or imply
a single-agent GRPO stage.

The split contract is
`geodisaster_source_path_trajectory_grouped_split_v4_20261015`. Records
connected by a source sample or declared input path remain in one split.
Routing additionally groups normalized analytical-content duplicates, so
path-renamed copies cannot cross the split. Exact complete model-visible
single-agent episodes (`messages` plus `tool_sequence`, excluding identity
metadata) are also grouped, even when their source samples differ. The final
2,629/292 split has zero shared source groups, declared paths,
routing-content fingerprints, or complete-trajectory fingerprints. Repeated
episodes within one split are retained for source provenance and receive
inverse complete-trajectory multiplicity through `training_weight`. The
published projection contains 41 such groups covering 114 records and zero
cross-split groups; the 2,921 rows must not be described as 2,921 statistically
independent scenes.

During SFT, the code repository constructs its internal validation partition
from connected components of both `split_group_id` and
`trajectory_content_group_id`; a component cannot contribute turns to both the
internal training and validation subsets. The compact multi-agent GRPO prompt
selector also keeps only one member of each canonical non-unit-weight duplicate
trajectory group while preserving six prompts for each of the 43 logical
types. These are derived training choices and do not modify this canonical
release.

GT-chain steps are causal: a downstream worker consumes the declared current
handle, not a hidden answer or a broad sample directory. A worker need not emit
the final answer object verbatim. The runtime answer-contract layer
deterministically projects requested status, units, fractions, and nested
output fields from substantive worker evidence. The model receives only the
published reference and never emits the resolved JSON. Correctness is decided
only on the complete resolved JSON under the per-type schema; matching isolated
numbers or an intermediate payload is insufficient.

All 2,921 multi-agent records and all 2,921 single-agent records use
`ANSWER_JSON:answer_1`. Every one of the 5,842 terminal SFT targets uses the
same exact reference-only action. The resolved worker projection is
value-identical to canonical gold for 2,058 records; the other 863 records have
the same complete structure and differ only by numeric display precision within
the published tolerance. All 2,921 receive strict structured correctness.

The 292-row test source is public reference gold, not a secret leaderboard.
For fair runtime evaluation, mount only the gold-free test-input projection and
its declared files in an isolated filesystem. On 2026-10-14 the task owner also
recorded human verification of all 2,921 canonical samples. Automated replay
and source checks provide separate reproducibility evidence.

## 7. Reproducible runtime and file authorization

The publication replay environment is CPython 3.10.12 on Linux x86-64. The
hash-locked environment fixes 13 packages, including Affine 2.4.0, NumPy
1.26.4, SciPy 1.11.4, Rasterio 1.4.3, PyProj 3.7.1, Shapely 2.1.2, and Pillow
11.3.0. The lock SHA-256 is
`6c0419601f785ed45b60ce5c2d2927ad070d6aab5d987c424c764b8d6e4a6456`.
Binary wheels and hashes are required; source-build or dependency substitution
is not permitted by the creation script. The reference native stack is GDAL
3.9.3, PROJ 9.5.1, and GEOS 3.13.1.

Create and verify it from the repository root:

```bash
release_tools/create_c11_replay_environment.sh
.venv-geodisaster-replay/bin/python release_tools/verify_c11_environment.py
```

Every tool call uses `opened_handle_exact_path_v1`: its read allowlist contains
only exact file cards reachable through the question/input/work handles opened
by that call. Ground truth, hidden/reference answers, trajectories,
selected-route files, undeclared siblings, and broad directory fallback are
denied at the read boundary. Deforestation quality reports are regenerated
from declared rasters; fetch-time reports are provenance only. Missing optional
epochs are reported rather than discovered by probing conventional filenames.

The final full replay audited 2,921 sessions, 14,611 tool calls, and 25,672
recorded reads with zero authorization violations. The isolated test replay
audited 292 sessions, 1,459 calls, and 2,587 reads with zero violations. Strict
isolation uses `GEODISASTER_STRICT_DATA_ROOT=1`, preventing fallback from the
test bundle into the development repository.

All 14,803 generated worker artifacts in the final full replay are nonempty.
The zero-byte `answer_support_gaps.jsonl` is intentionally an empty audit
ledger meaning that no record lacks answer evidence; it is not an agent answer
or a generated geospatial artifact.

## 8. Shared geospatial and source-data contracts

`ATTRIBUTIONS.md` is the authoritative file-family registry. It maps every
packaged source and internal support category to its upstream product,
citation, applicable terms, transformation, and redistribution status. The
package is mixed-license: the project's CC-BY-4.0 terms for authored questions,
schemas, chains, and documentation do not relicense upstream imagery, labels,
or derived products. Earth Engine and OSMnx are processing facilities, not
substitutes for citing the underlying products.

The retained development-snapshot audit classifies all 10,831 physical source
files, every canonical reference, and every multi-hazard source label, with
zero uncited or unregistered categories. The thin public release contains
9,328 files and its hydrated execution form contains 9,628; the mode-aware
audit verifies the appropriate inventory and permits no unexpected missing
required path. OpenAQ files record empty-query provenance only and are never
answer evidence. WorldPop and OpenStreetMap are actual exposure inputs and
retain their attribution requirements. The project-supplied xBD
intermediate package is not treated as a separate external source; underlying
xBD/xView2 imagery and labels retain their original attribution and
non-commercial conditions.

Shared numerical rules are:

- nodata is excluded while a valid numeric zero remains a measurement;
- geographic raster areas sum WGS84 ellipsoidal cell areas, while projected
  grids use the affine determinant;
- comparisons require the declared shape, CRS, and affine compatibility;
- source geometry is transformed through the raster's real CRS and affine—no
  synthetic origin-zero transform is permitted;
- null is used only where the schema declares a valid undefined/absent state;
  it is not a substitute for a missing file or failed computation; and
- shared workers branch on declared domain/handle metadata, never on a sample
  ID or expected answer.

Official Sen1Floods11 `S1Hand.tif` bytes remain immutable provenance. The
hydrator creates portable `S1Portable.tif` inputs with finite nodata `-9999`
while preserving finite pixels, dimensions, CRS, transform, Otsu threshold,
and prediction. Cached Otsu/hand-label support products have zero canonical
input references and are prohibited answer inputs.

## 9. Honest scope and interpretation limits

The benchmark's published claim includes the following scientific and
evaluation limits:

- Tasks use fixed cached inputs for reproducibility; they do not measure live
  upstream discovery, API reliability, or real-time hazard status.
- Routing validates and renders packaged candidates. It is not a fresh road-
  graph search, a proof of globally nearest shelter, or evacuation advice.
- Deforestation causes, drought/air classes, and multi-source agreement are
  explicit remote-sensing or benchmark-relative proxy constructs, not field-
  verified causality, health categories, or regulatory determinations.
- Cached OSM way/relation centers are representative points, not complete line
  geometries. Questions and answers use that wording deliberately.
- Sen1 A–E analyze a deterministic Otsu flood-candidate prediction, not its
  hand-label accuracy. The evaluator-only 100-scene check measures macro
  IoU/F1 0.206884/0.278917 and micro IoU/F1 0.206212/0.341916; this supports a
  reproducible high-recall/low-precision candidate baseline, not operational
  flood mapping.
- The published population includes class imbalance, valid zero masks/counts,
  null branches, identical routing candidates, and source disagreement. It is
  designed for task-family coverage rather than balanced target classes.
- Automated checks establish execution, dataflow, source consistency, and
  reproducibility. They do not waive upstream license conditions or create an
  unperformed independent scientific field validation.

## 10. Public-release procedure

The complete development workspace retains Sen1Floods11 files for local
reproducibility. Because the upstream repository does not state an
authoritative redistribution license for that payload, a public archive must
exclude `source_assets/sen1_flood/` and retain:

- `release_tools/fetch_sen1floods11_subset.py`;
- `release_tools/manifests/sen1floods11_required_100.json`;
- `release_tools/manifests/c10_excluded_legacy_rasters.json`; and
- `release_tools/evaluate_c12_sen1_accuracy.py` for evaluator-only construct
  validation, without mounting `LabelHand` files in the agent runtime.

In a clean public-release root, hydrate directly from the official source,
verify checksums and deterministic derivatives, then replay all 500 Sentinel
questions:

```bash
python3 release_tools/fetch_sen1floods11_subset.py
python3 release_tools/fetch_sen1floods11_subset.py --verify-only
.venv-geodisaster-replay/bin/python release_tools/replay_all_2921.py \
  --dataset-root . \
  --code-root /path/to/GeoDisaster/code \
  --input-jsonl data/core/geodisaster_2921_source_with_splits.jsonl \
  --output-dir /path/outside/repository/public_sen1_replay \
  --family sen1_flood --workers 8
python3 release_tools/audit_c01_source_registry.py --mode hydrated \
  --output /path/outside/repository/source_registry_hydrated.json
```

The source registry/path audit and 500/500 replay must pass before upload.
The replay command projects a fresh final answer from the newly executed worker
payloads and applies the active strict structured scorer. Stored historical
`source_replay.matches_expected` flags and scalar evidence coverage are reported
as provenance/diagnostics only and cannot produce an end-to-end pass.
Preserve the complete development copy separately; construct the public
archive from a clean release root.

# Question type 1 of 43 — deforestation `forest_loss_detection`

## Task and coverage

The agent decides whether real forest loss occurred in the stated event
window. It must return `deforestation` or `no_deforestation` together with
Hansen loss area, optical NDVI drop, Sentinel-1 VH change, and the rules that
produced the decision.

- Records: 48 AOIs — 43 train and 5 test.
- Event years represented: 2019, 2020, 2021, 2022, and 2023.
- Final labels: 27 `deforestation`, 21 `no_deforestation`.
- One answer schema and one tool-name sequence are used for all 48 records.
- All 48 records have `training_weight=1.0`; this type contains no
  downweighted content aliases.

## What the agent must do and infer

**Do.** Open the optical, SAR, and Hansen handles; prepare one compatible
forest-change work context; request a cross-source comparison; classify that
comparison with the declared binary rule; and produce sufficient evidence for
the runtime to publish the exact schema-valid answer reference.

**Infer.** Decide whether the combined measurements represent genuine
deforestation. The agent cannot equate any visible color change with forest
loss or copy a prewritten label. It must use the analytical result that
distinguishes confirmed forest loss from plantation harvest, water/flood
edges, burn/bare soil, agricultural change, and no strong change signal. It
then maps only the generic `deforestation` cause to the positive binary label.

**Meaning in the benchmark.** This task measures multi-modal evidence
integration and causal tool use: optical imagery can show vegetation change,
SAR can provide cloud-independent structural evidence, and Hansen supplies an
independent loss-year/baseline-forest constraint. Success demonstrates that
the agent can route three complementary real-source inputs through the correct
workers, preserve their provenance, interpret the resulting rule evidence,
and produce a strictly structured conclusion. It does not test live satellite
download or ask the model to classify RGB pixels without tools.

## Declared sources and files

All files for an AOI are below
`source_assets/deforestation/<sample_id>/` and are exposed through exactly
three analytical input handles.

| Handle | Declared files | Purpose |
|---|---|---|
| `optical_stack_1` | Five or six `cache/s2/{pre_*,post_*}.tif` files and matching `visible/s2_rgb/*.png` panels | Sentinel-2 B2/B3/B4/B8/B11/B12 data for NDVI/NBR; PNGs provide visual context. Twenty-seven AOIs have six epochs and 21 have five; every AOI retains usable pre and post epochs. |
| `sar_stack_1` | Five `cache/s1_grd/s1_*.tif` files | Sentinel-1 VV/VH evidence. Every AOI has two declared pre-event and three post-event acquisitions. Each path carries its real acquisition date and `temporal_role`. |
| `forest_mask_1` | `masks/loss_year_<event_year>.tif`, `masks/lossyear.tif`, and `masks/treecover2000.tif` | Event-year Hansen loss, full loss-year codes, and baseline canopy. |

The direct upstream products are
[Sentinel-2 L2A SR Harmonized](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR_HARMONIZED),
[Sentinel-1 GRD](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S1_GRD),
and [Hansen/UMD Global Forest Change v1.13](https://developers.google.com/earth-engine/datasets/catalog/UMD_hansen_global_forest_change_2025_v1_13).
Google Earth Engine was the acquisition/processing platform, not an additional
data source.

Fetch-time `quality_report.json` files may remain beside the data for
provenance, but they are not declared analytical inputs. Runtime quality is
recomputed from the three Hansen rasters opened through `forest_mask_1`.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, optical_stack_1, role=pre_post, time=event_window)` | Declared optical files and metadata | `scene_1` |
| 2 | `ReadData(question_1, sar_stack_1, role=pre_post, time=event_window)` | Declared SAR files, dates, and roles | `scene_2` |
| 3 | `ReadData(question_1, forest_mask_1, role=hansen)` | Hansen paths and a fresh raster-quality report | `scene_3` |
| 4 | `PrepareScene(inputs={optical:scene_1, sar:scene_2, forest:scene_3}, mode=forest_change)` | Input types, roles, path status, and lineage | `work_1` |
| 5 | `CompareSources(work_1, signals=optical_sar_hansen, criterion=forest_loss_support)` | Optical, SAR, Hansen, and generic cause classification | `compare_1` |
| 6 | `ClassifyChange(compare_1, rule=forest_loss, labels={positive:deforestation, negative:no_deforestation})` | Consumes the comparison result and maps its cause to the binary task label | `class_1` and final answer evidence |
| 7 | `TaskComplete` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ClassifyChange` consumes `compare_1`; it does not bypass the comparison and
silently recompute from `work_1`. Thus every analytical step in this chain is
causal.

## Calculation and decision contract

1. For each available Sentinel-2 epoch:
   `NDVI = (B8 - B4) / (B8 + B4)` and
   `NBR = (B8 - B12) / (B8 + B12)`.
2. The optical drop is `mean(pre) - mean(post)`. If the annual Hansen mask has
   positive loss pixels, the optical means are restricted to that loss region;
   otherwise the calculation uses the valid AOI pixels.
3. Sentinel-1 values are aggregated in dB using only the declared temporal
   roles. `sar_vh_delta_db = post_mean_db - pre_mean_db`; a negative value is
   a backscatter decrease.
4. Event-year loss is the sum of positive valid annual-mask cell areas.
   Geographic rasters use WGS84 ellipsoidal cell areas and projected rasters
   use the affine determinant. Hectares are rounded to six decimals.
5. If the annual mask contains no valid pixels, the worker—not the agent—uses
   the declared `lossyear.tif` code `event_year - 2000`. Valid code 0 means
   no loss. Nodata is 255 and is excluded.
6. The generic cause classifier applies these ordered rules:
   - Hansen loss at least 0.5 ha and baseline canopy at least 50%:
     `deforestation`;
   - Hansen loss at least 0.5 ha but canopy below 50%:
     `plantation_harvest`;
   - no Hansen confirmation, but NDVI drop above 0.25 and VH delta below
     -1.5 dB: `deforestation` with a missing-Hansen flag;
   - otherwise it may identify water/flood edge, burn/bare soil,
     agriculture, or no change from the published generic thresholds.
7. This binary task returns `deforestation` only when the generic cause is
   exactly `deforestation`; every other cause maps to `no_deforestation`.

No rule branches on an AOI ID or expected answer. Unsupported comparison
criteria, labels, rules, roles, or times are rejected.

## Final answer contract

The answer is exactly:

```json
{
  "label": "deforestation | no_deforestation",
  "evidence": {
    "hansen_loss_area_ha": 0.0,
    "ndvi_drop": 0.0,
    "rules_fired": ["ordered rule strings"],
    "sar_vh_delta_db": 0.0
  }
}
```

The numbers above illustrate types, not target values. All four evidence
fields are required, extra fields are rejected, and `rules_fired` order is
significant. The agent formats this schema from `class_1`; it must not answer
from the RGB panel alone.

## Edge cases and verified result

- Missing one optical epoch is allowed because 21 AOIs legitimately contain
  five rather than six epochs; both temporal sides must still be measurable.
- Missing SAR role metadata or an empty pre/post SAR group is an error.
- Zero canopy and zero loss are valid measurements; 255 is nodata.
- An all-nodata annual mask triggers the declared full-loss-year fallback; it
  is not treated as a zero-sized or successful empty output.
- Required evidence must be finite. No record in this type returns an empty
  answer or empty required artifact.

**Validated contract.** All declared files exist, the three
sources are used for their stated roles, the chain is causal, the worker logic
matches the question and schema, and 48/48 records passed execution plus
field-aware answer validation.

---

# Question type 2 of 43 — deforestation `area_estimation`

## Task and coverage

The agent measures the total Hansen event-year forest-loss area inside the AOI
and reports Sentinel-2 NDVI/NBR change over the same detected region as
validation evidence. This is a quantitative area task; it does not request or
return a binary deforestation label.

- Records: 48 AOIs — 43 train and 5 test.
- Event years represented: 2019, 2020, 2021, 2022, and 2023.
- Results: 28 positive-area and 20 valid zero-area records.
- Observed area range: 0 to 265.910267 ha.
- One answer schema and one tool-name sequence are used for all 48 records.
- All 48 records have `training_weight=1.0`.

## What the agent must do and infer

**Do.** Open the Hansen and optical handles, prepare the forest-change work
context, extract the event-year loss patches, measure their total area in
hectares, and request NDVI/NBR validation against Hansen. The runtime projects
the complete worker evidence into the exact area-and-evidence JSON schema.

**Infer.** Identify the correct event year from the question, interpret valid
Hansen loss pixels rather than nodata, and distinguish a genuine zero-area
measurement from an absent annual observation. The agent must combine the
area result and the parallel optical-validation result. It must not invent a
binary class or reject a source-derived area merely because an optical drop is
small or negative.

**Meaning in the benchmark.** This task measures quantitative geospatial tool
use: selecting the correct temporal raster, extracting a spatial phenomenon,
measuring it on its real grid, and supporting that measurement with a second
sensor-derived modality. It tests whether the agent can combine parallel
analytical evidence into a strict final schema without confusing area
measurement with classification.

## Declared sources and files

| Handle | Declared files | Purpose |
|---|---|---|
| `forest_mask_1` | `loss_year_<event_year>.tif`, `lossyear.tif`, and `treecover2000.tif` | Hansen event-year mask, fallback loss-year codes, and baseline canopy metadata. |
| `optical_stack_1` | Five or six Sentinel-2 six-band GeoTIFFs plus matching RGB panels | NDVI and NBR validation. Twenty-seven AOIs have six optical epochs and 21 have five; all have usable pre and post observations. |

The upstream sources are
[Hansen/UMD Global Forest Change v1.13](https://developers.google.com/earth-engine/datasets/catalog/UMD_hansen_global_forest_change_2025_v1_13)
and
[Sentinel-2 L2A SR Harmonized](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR_HARMONIZED).
No SAR handle is exposed because this question neither asks for nor uses SAR.
Across this type, all 726 declared path references exist and remain inside the
repository.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output role |
|---:|---|---|---|
| 1 | `ReadData(question_1, forest_mask_1, role=hansen)` | Hansen files plus a fresh runtime quality report | `scene_1` |
| 2 | `ReadData(question_1, optical_stack_1, role=pre_post, time=event_window)` | Optical paths and temporal role | `scene_2` |
| 3 | `PrepareScene(inputs={forest:scene_1, optical:scene_2}, mode=forest_change)` | Compatible inputs, path status, and lineage | `work_1` |
| 4 | `ExtractObjects(work_1, target=forest_loss_patches, filters={event_year:<question year>})` | Event-year mask selection, connected-patch summary, pixel count, and grid-aware area report | `objects_1` |
| 5 | `MeasureArea(objects_1, target=forest_loss, unit=hectares)` | Consumes the extracted-object report and returns area in hectares and square metres | `area_1` |
| 6 | `CompareSources(work_1, signals=ndvi_nbr_vs_hansen, criterion=validation)` | Computes loss-region NDVI/NBR drops and the independently reported Hansen area | `compare_1` |
| 7 | `TaskComplete` | Closes the specialist subgoal after `area_1` and `compare_1` are available; carries no terminal answer | ORC termination by published answer reference |

`ExtractObjects -> MeasureArea` is causal. `MeasureArea` and `CompareSources`
are intentionally parallel final-evidence branches: the first supplies the
requested measurement and the second supplies the requested cross-source
validation. Neither output is decorative or bypassed.

## Calculation contract

1. `ExtractObjects` requires exactly `target=forest_loss_patches` and an
   `event_year` matching the question. A missing, malformed, additional, or
   conflicting filter is rejected.
2. Valid positive cells in `loss_year_<event_year>.tif` define the preferred
   loss mask. Declared nodata and non-finite cells are excluded.
3. If the annual mask has no valid cells, the worker selects code
   `event_year - 2000` from the declared full `lossyear.tif`. Code 0 is valid
   no loss; nodata is 255. The fallback is a data-validity decision made by
   the worker, not a file choice delegated to the agent.
4. Area is summed cell by cell: WGS84 ellipsoidal area for geographic grids
   or affine-determinant area for projected grids. The result is rounded to
   six decimals in hectares.
5. `ExtractObjects` records the component count and largest-patch size in its
   intermediate report. `MeasureArea` validates the requested target/unit and
   consumes this result before exposing the final area measurement.
6. `CompareSources` computes
   `NDVI=(B8-B4)/(B8+B4)` and `NBR=(B8-B12)/(B8+B12)`, then reports
   `mean(pre)-mean(post)`. When positive Hansen loss pixels exist, optical
   evidence is restricted to that region; otherwise valid AOI pixels are used.
7. Optical values are validation evidence, not an alternative area estimate
   and not a hidden threshold that changes the Hansen area.

These are sample-independent rules. `ExtractObjects`, `MeasureArea`, and
`CompareSources` reject unsupported target, year, unit, signal, or criterion
arguments rather than silently applying a default.

## Final answer contract

The answer is exactly:

```json
{
  "loss_area_ha": 0.0,
  "evidence": {
    "hansen_loss_area_ha": 0.0,
    "ndvi_drop": 0.0,
    "nbr_drop": 0.0
  }
}
```

The numbers illustrate types only. `loss_area_ha` is the requested result;
`evidence.hansen_loss_area_ha` identifies and confirms its source, so the two
values must agree. NDVI and NBR drops may be positive, zero, or negative and
must remain finite. The schema intentionally contains no `label` field.

## Edge cases and verified result

- Twenty records correctly return `0.0 ha`; these are measurements, not empty
  answers.
- Ten AOIs have annual masks with no valid cells. Every one correctly uses the
  declared full `lossyear.tif` fallback and resolves to valid code-0 no loss.
- A five-epoch optical stack is valid when both pre and post evidence remain.
- No record has a missing, null, non-finite, or contradictory required field.
- The top-level and evidence Hansen areas agree in 48/48 records.

**Validated contract.** The canonical event-year arguments are
correct in all 48 chains. The shared `ExtractObjects` worker rejects a filter
year that conflicts with the question. The fresh focused run passed 48/48 executions,
48/48 field-aware answers, 726/726 paths, and produced 336 nonempty artifacts.
A repository-wide regression passes 2,921/2,921 executions and
2,921/2,921 field-aware checks across all 43 types. Downstream MA, SA, turn,
and role-SFT representations are verified exact projections of the canonical
records.

---

# Question type 3 of 43 — deforestation `change_window_estimation`

## Task and coverage

The agent localizes the dominant optical clearing interval, conditions that
interval on independently confirmed Hansen event-year loss, and reports
whole-period optical/SAR context plus the selected-window score.

- Records: 48 AOIs — 43 train and 5 test.
- Results: 28 `deforestation` records with a window and 20
  `no_deforestation` records with a null window.
- Confirmed-loss area range: 13.326184 to 265.910267 ha; all unconfirmed
  records have valid 0 ha measurements.
- One answer schema and one tool-name sequence are used for all 48 records.
- All 48 records have `training_weight=1.0`.

## What the agent must do and infer

**Do.** Open the optical time series, SAR time series, and Hansen handles;
prepare one temporal forest work context; detect the dominant adjacent optical
interval; classify the resulting detection under the Hansen gate; and return
the label, nullable interval, and six exact evidence fields.

**Infer.** Determine which adjacent pair of *available* optical epochs has the
largest `NDVI_drop + 0.5*NBR_drop`, then decide whether that optical
fluctuation may be reported as a clearing interval. A candidate becomes a
reported interval only when the independent event-year Hansen area is at
least 0.5 ha. The agent must distinguish a valid null interval from an
execution failure and must not treat SAR as the interval-selection signal.

**Meaning in the benchmark.** This task measures temporal localization,
cross-source confirmation, missing-epoch reasoning, and causal artifact use.
Sentinel-2 identifies *when* the strongest optical transition occurs, Hansen
decides whether the transition is supported as event-year forest loss, and
Sentinel-1 supplies independent whole-period structural context. It tests
whether the agent can preserve these distinct source roles rather than
collapsing every change signal into a positive answer.

## Declared sources and files

| Handle | Declared files | Purpose |
|---|---|---|
| `optical_timeseries_1` | Five or six Sentinel-2 six-band `cache/s2/{pre_*,post_*}.tif` files and matching RGB panels | AOI-wide per-epoch NDVI/NBR means for interval selection and optical support evidence. |
| `sar_timeseries_1` | Five Sentinel-1 `cache/s1_grd/s1_*.tif` files | Whole-period VH context from two declared pre-event and three post-event acquisitions with per-path dates and temporal roles. |
| `forest_mask_1` | `loss_year_<event_year>.tif`, `lossyear.tif`, and `treecover2000.tif` | Grid-aware event-year Hansen loss confirmation, fallback codes, and baseline canopy metadata. |

The upstream products are
[Sentinel-2 L2A SR Harmonized](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR_HARMONIZED),
[Sentinel-1 GRD](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S1_GRD),
and [Hansen/UMD Global Forest Change v1.13](https://developers.google.com/earth-engine/datasets/catalog/UMD_hansen_global_forest_change_2025_v1_13).
Across this type, all 966 declared path references exist, are nonempty, and
remain inside the repository.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output role |
|---:|---|---|---|
| 1 | `ReadData(question_1, optical_timeseries_1, role=ndvi_nbr, time=pre_post_epochs)` | Declared Sentinel-2 epochs and temporal metadata | `scene_1` |
| 2 | `ReadData(question_1, sar_timeseries_1, role=vh, time=pre_post_epochs)` | Declared Sentinel-1 files, dates, and pre/post roles | `scene_2` |
| 3 | `ReadData(question_1, forest_mask_1, role=hansen)` | Hansen files and fresh runtime raster quality | `scene_3` |
| 4 | `PrepareScene(inputs={optical:scene_1, sar:scene_2, forest:scene_3}, mode=forest_timeseries)` | Compatible types, roles, path status, and lineage | `work_1` |
| 5 | `DetectChange(work_1, change=dominant_clearing_interval, window=pre_post_epochs)` | Candidate interval, Hansen gate, and all requested evidence | `change_1` |
| 6 | `ClassifyChange(change_1, rule=change_window, labels={none:null, changed:start_epoch_to_end_epoch})` | Validates and formats the preceding detection result | `class_1` and final-answer evidence |
| 7 | `TaskComplete` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ClassifyChange` consumes `change_1` directly. It performs zero raw-file
reads and cannot recompute a different bundle from `work_1`; an incorrect
input handle is rejected.

## Calculation and decision contract

1. For every declared optical epoch, the worker computes AOI-wide valid-pixel
   means for `NDVI=(B8-B4)/(B8+B4)` and `NBR=(B8-B12)/(B8+B12)`.
2. Only epochs with finite values for both indices are eligible. Eligible
   epochs retain canonical order `pre_3, pre_2, pre_1, post_1, post_2,
   post_3`; an undeclared epoch is skipped.
3. For each adjacent eligible pair `(a,b)`,
   `NDVI_drop=NDVI[a]-NDVI[b]`, `NBR_drop=NBR[a]-NBR[b]`, and
   `score=NDVI_drop+0.5*NBR_drop`. The maximum score wins; an exact tie uses
   the earliest pair in canonical order.
4. Hansen event-year area follows the same nodata, annual-mask fallback, and
   grid-aware cell-area rules documented for area estimation. Area at least
   0.5 ha confirms the candidate; a smaller area produces
   `no_deforestation`, a null window, and null selected-window fields.
5. The separately reported whole-period NDVI drop is
   `mean(pre)-mean(post)` within positive event-year loss pixels when present,
   otherwise over valid AOI pixels. It supports the answer but does not select
   the interval.
6. `sar_vh_delta_db=post_mean_db-pre_mean_db` uses the declared Sentinel-1
   temporal roles. SAR is contextual evidence, not a hidden gate or optical
   interval selector.
7. Confirmed Hansen loss without at least two eligible optical epochs is an
   explicit processing error, not a misleading null/no-deforestation answer.

No rule branches on sample identity or target values. Unsupported change,
window, rule, label, or source-handle arguments fail.

## Final answer contract

The answer is exactly:

```json
{
  "label": "deforestation | no_deforestation",
  "change_window": {"start_epoch": "pre_1", "end_epoch": "post_1"},
  "evidence": {
    "hansen_loss_area_ha": 0.0,
    "ndvi_drop": 0.0,
    "sar_vh_delta_db": 0.0,
    "selected_window_ndvi_drop": 0.0,
    "selected_window_nbr_drop": 0.0,
    "composite_drop_score": 0.0
  }
}
```

The values illustrate types only. For `no_deforestation`, `change_window` and
the three `selected_window_*`/`composite_drop_score` fields are `null`; Hansen,
whole-period NDVI, and SAR evidence remain finite numeric measurements. For
`deforestation`, the interval object and all selected-window values are
required, and the composite score equals the declared formula.

## Edge cases and verified result

- Twenty-one AOIs contain five optical epochs rather than six. The worker
  forms adjacency over the declared available sequence; seven selected
  windows therefore legitimately span the name of one missing epoch.
- Twenty null windows are intentional negative outcomes, not empty files,
  empty masks, or missing answers.
- All 28 reported windows have finite NDVI, NBR, and composite values; the
  formula agrees exactly in 28/28 records.
- All 48 classification steps consumed `change_1` with zero raw reads.
- No required numeric field is non-finite and no required source is missing.

**Validated contract.** The prompt requests every schema field
and states both the available-epoch and spatial-scope rules. Missing NBR is an
error, and the classification worker directly consumes the detection artifact. A
fresh focused replay passed 48/48 executions, 48/48 field-aware validations,
966/966 paths, and produced 336 nonempty artifacts.

---

# Question type 4 of 43 — deforestation `false_positive_rejection`

## Task and coverage

The agent applies a declared ordered rule set to distinguish the operational
remote-sensing pattern behind an apparent change. The six outputs are
benchmark proxy classes, not independently field-verified statements of
real-world causation.

- Records: 48 AOIs — 43 train and 5 test.
- Outputs: 27 `deforestation`, 2 `plantation_harvest`, 3 `burn_bare_soil`,
  5 `agriculture`, and 11 `no_change`.
- `water_flood_edge` is a valid reachable schema/rule state but does not occur
  in the current 48-record population.
- One answer schema and one tool-name sequence are used for all 48 records.
- All 48 records have `training_weight=1.0`.

## What the agent must do and infer

**Do.** Open the optical, SAR, and Hansen handles; prepare a false-positive
analysis context; compare all three sources under `cause_attribution`;
classify that comparison using the six-class ordered proxy rule; and return
the exact class plus every structured measurement and ordered rule string
required by the schema.

**Infer.** Determine the first matching operational pattern in the published
rule order. The agent must preserve the distinction between a Hansen-confirmed
loss pattern, a strong unconfirmed optical/SAR pattern, possible water-like
SAR, burn/bare-soil-like optical change, agriculture-like vegetation change,
and no strong signal. It must not present the proxy name as proof of actual
land-use cause.

**Meaning in the benchmark.** This task measures confuser-aware reasoning and
ordered decision execution. It asks whether the agent can combine multiple
sensors, respect precedence between rules, carry a comparison artifact into a
classification worker, and report enough exact evidence for the result to be
audited. It measures consistent tool-mediated attribution under a declared
benchmark taxonomy, not field causal discovery.

## Declared sources and files

| Handle | Declared files | Purpose |
|---|---|---|
| `optical_stack_1` | Five or six Sentinel-2 six-band GeoTIFFs and matching RGB panels | NDVI/NBR change patterns over the loss region when present, otherwise the AOI. |
| `sar_stack_1` | Five Sentinel-1 VV/VH GeoTIFFs | Whole-period VH change and post-event VV mean from declared pre/post acquisition roles. |
| `forest_mask_1` | Event-year mask, full `lossyear.tif`, and `treecover2000.tif` | Hansen loss area and AOI baseline canopy mean. |

The sources are
[Sentinel-2 L2A SR Harmonized](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR_HARMONIZED),
[Sentinel-1 GRD](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S1_GRD),
and [Hansen/UMD Global Forest Change v1.13](https://developers.google.com/earth-engine/datasets/catalog/UMD_hansen_global_forest_change_2025_v1_13).
All 966 declared path references exist, are nonempty, and remain inside the
repository.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output role |
|---:|---|---|---|
| 1 | `ReadData(question_1, optical_stack_1, role=pre_post, time=event_window)` | Optical files and epoch coverage | `scene_1` |
| 2 | `ReadData(question_1, sar_stack_1, role=pre_post, time=event_window)` | SAR files, dates, and temporal roles | `scene_2` |
| 3 | `ReadData(question_1, forest_mask_1, role=hansen)` | Hansen files and runtime raster quality | `scene_3` |
| 4 | `PrepareScene(inputs={optical:scene_1, sar:scene_2, forest:scene_3}, mode=forest_false_positive)` | Compatible types, roles, paths, and lineage | `work_1` |
| 5 | `CompareSources(work_1, signals=optical_sar_hansen, criterion=cause_attribution)` | All source measurements and ordered proxy classification | `compare_1` |
| 6 | `ClassifyChange(compare_1, rule=false_positive_type, labels=<six declared classes>)` | Validates and formats the preceding comparison | `class_1` and final-answer evidence |
| 7 | `TaskComplete` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ClassifyChange` requires a `cause_attribution` comparison and consumes
`compare_1` directly. Across all 48 records it performed zero raw-file reads;
passing `work_1` is rejected rather than triggering hidden recomputation.

## Ordered proxy-rule contract

The worker first requires finite NDVI drop, NBR drop, VH delta, post-event VV
mean, canopy mean, and Hansen loss area. Negative loss area or canopy outside
0–100% is an error. It then applies the first matching rule:

1. Hansen loss area at least 0.5 ha and canopy mean at least 50%:
   `deforestation`.
2. Hansen loss area at least 0.5 ha and canopy below 50%:
   `plantation_harvest`.
3. No confirmed Hansen loss, NDVI drop above 0.25, and VH delta below -1.5 dB:
   `deforestation` with a `missing_hansen_confirmation` intermediate flag.
4. No confirmed Hansen loss and post-event VV mean below -16 dB:
   `water_flood_edge`.
5. No confirmed Hansen loss, NBR drop above 0.20, and NBR drop greater than
   NDVI drop: `burn_bare_soil`.
6. No confirmed Hansen loss and NDVI drop above 0.10: `agriculture`.
7. Otherwise: `no_change`.

Optical drops use `mean(pre)-mean(post)` and are restricted to positive
event-year Hansen pixels when available, otherwise valid AOI pixels. VH delta
is `post-pre`; post-event VV is the declared post-group mean. Canopy is the
valid-pixel mean of `treecover2000.tif`. Hansen area uses the documented
grid-aware/fallback contract. These fixed thresholds are operational taxonomy
rules, not universal ecological definitions.

## Final answer contract

```json
{
  "cause": "deforestation | plantation_harvest | water_flood_edge | burn_bare_soil | agriculture | no_change",
  "evidence": {
    "hansen_loss_area_ha": 0.0,
    "nbr_drop": 0.0,
    "ndvi_drop": 0.0,
    "rules_fired": ["ordered rule strings"],
    "sar_vh_delta_db": 0.0,
    "sar_vv_post_mean_db": 0.0,
    "treecover2000_mean_pct": 0.0
  }
}
```

The numbers illustrate types only. All six measurements are finite and all
seven evidence keys are required. `rules_fired` is nonempty and ordered; extra
answer fields are rejected.

## Edge cases and verified result

- The schema retains all six declared classes, including classes absent from
  some source populations.
- A five-epoch optical stack remains valid when pre and post means exist.
- Zero Hansen loss is a valid measurement and activates only the later
  unconfirmed-signal rules; it is not an empty mask result.
- The answer explicitly exposes canopy and post-event VV as structured
  evidence.
- No required field is null, non-finite, or missing in any of the 48 records.

**Validated contract.** The
class labels, numeric decisions, and exact rule inputs are structured and
auditable in all 48 targets.
The focused replay passed 48/48 executions, 48/48 field-aware validations,
966/966 paths, and 336 nonempty artifacts. The shared forest-loss path also
passed 48/48, and the repository-wide regression passed
2,921/2,921 executions and field-aware checks across all 43 types.

---

# Question type 5 of 43 — deforestation `baseline_canopy_assessment`

## Task and coverage

The agent computes mean baseline canopy density from the Hansen
`treecover2000` raster and assigns exactly one density class.

- Records: 48 AOIs — 43 train and 5 test.
- Classes: 31 `dense_forest`, 7 `open_canopy`, and 10 `sparse`.
- Observed means range from 2.1365201473236084% to 99.99832916259766%.
- All 48 records have `training_weight=1.0`.

## What the agent must do and infer

**Do.** Open the one declared Hansen baseline raster, prepare the canopy work
context, request its valid-pixel AOI mean, classify that computed statistic,
and produce sufficient evidence for the runtime to publish the exact
two-field JSON answer reference.

**Infer.** Determine the class from the computed mean: `dense_forest` when the
mean is greater than 60%, `open_canopy` when it is from 30% through 60%
inclusive, and `sparse` below 30%. The class is not stored in the input and
cannot be inferred from a loss mask.

**Meaning in the benchmark.** This task measures whether an agent can select
the minimal relevant raster, invoke a quantitative statistic, preserve the
statistic-to-class causal dependency, and obey exact boundary and nodata
semantics. It is a baseline canopy-density proxy, not a field survey or a
claim that the mean alone defines ecological forest condition.

## Declared source and file

The only analytical input is:

| Handle | Declared file | Purpose |
|---|---|---|
| `forest_mask_1` | `source_assets/deforestation/<sample_id>/masks/treecover2000.tif` | Hansen percent tree cover for year 2000 on the packaged AOI grid. |

The upstream product is
[Hansen/UMD Global Forest Change v1.13](https://developers.google.com/earth-engine/datasets/catalog/UMD_hansen_global_forest_change_2025_v1_13).
No optical, SAR, annual-loss, or full `lossyear.tif` input is exposed or read
for this task. Across the type, all 96 declared path references—the question
JSON and tree-cover raster for each record—exist inside the repository.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, forest_mask_1, role=hansen)` | The exact declared tree-cover path; it does not build a loss-quality report | `scene_1` |
| 2 | `PrepareScene(inputs={forest:scene_1}, mode=baseline_canopy)` | Input type, role, path status, and lineage | `work_1` |
| 3 | `ComputeStats(work_1, metrics={treecover_mean_pct:true}, region=aoi)` | Valid-pixel arithmetic mean and valid-pixel count | `stats_1` |
| 4 | `ClassifyChange(stats_1, rule=canopy_density, labels=<declared thresholds>)` | Validates and classifies the preceding statistic | `class_1` |
| 5 | `TaskComplete` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ClassifyChange` accepts only the matching baseline-canopy `stats_1` result,
checks that its embedded class agrees with the mean, and performs no raw-file
read. Passing `work_1`, an unsupported metric/region, or inconsistent result
is an error.

## Calculation and decision contract

1. Read band 1 of the declared `treecover2000.tif` only.
2. Exclude non-finite pixels and the declared finite nodata value 255.
   Tree-cover value 0 is valid, and all valid values must lie in 0–100.
3. Fail if no valid pixels remain; otherwise compute the unrounded arithmetic
   mean over all valid pixels in the packaged AOI raster.
4. Classify the mean with mutually exclusive, exhaustive boundaries:
   - `dense_forest`: mean > 60;
   - `open_canopy`: 30 <= mean <= 60;
   - `sparse`: mean < 30.

The rules are sample-independent and contain no AOI-ID or expected-answer
branch. Both statistic and classification workers reject missing, non-finite,
negative, or above-100 canopy values.

## Final answer contract

```json
{
  "baseline_class": "dense_forest | open_canopy | sparse",
  "treecover2000_mean_pct": 0.0
}
```

The number illustrates the type, not a target value. Both keys are required,
the class is enum-constrained, and extra keys are rejected.

## Edge cases and verified result

- Exact means 30 and 60 belong to `open_canopy`; values immediately below 30
  are `sparse`, and values immediately above 60 are `dense_forest`.
- Every packaged raster has at least one valid pixel. No record returns null,
  NaN, infinity, an empty artifact, or an unknown class.
- Direct source recomputation reproduces all 48 stored means and classes.
- The 48-record focused replay passed 48/48 executions and 48/48 field-aware
  validations, produced 192 nonempty artifacts, and found zero missing,
  absolute, or outside-root paths.

**Validated contract.** The final worker uses a dedicated
tree-cover-only computation, the public
inventory declares only that required raster, the 30/60 boundaries are
unambiguous, and the classification step is causally tied to `stats_1`. The
repository-wide regression remains 2,921/2,921 for execution and field-aware
validation across all 43 types.

---

# Question type 6 of 43 — deforestation `multi_year_loss_attribution`

## Task and coverage

The agent attributes the largest mapped Hansen tree-cover-loss area in the AOI
to one calendar year within 2001–2023.

- Records: 48 AOIs — 43 train and 5 test.
- Results: 35 records with a winning year and 13 valid `no_loss` records.
- Positive winners span 2002–2023 and 0.07951–616.31121 ha.
- No current record has a tie for the largest six-decimal area.
- All 48 records have `training_weight=1.0`.

## What the agent must do and infer

**Do.** Open the full Hansen loss-year raster, prepare a loss-history work
context, compute grid-aware area independently for codes 1–23, detect the
largest annual value, and return exactly its calendar year and six-decimal
area—or the declared `no_loss` result.

**Infer.** Convert Hansen code `n` to year `2000+n`, select the maximum from
the computed annual histogram, apply the earliest-year rule if equal rounded
areas occur, and distinguish valid code 0 from missing data. Neither the
winning year nor its area is stored in the exposed input.

**Meaning in the benchmark.** This task measures temporal attribution over a
categorical geospatial raster, grid-aware area calculation, deterministic
selection, and causal use of a statistics artifact. “Loss” means Hansen's
mapped tree-cover loss signal; it is not by itself a field-verified causal
attribution or a live forest-monitoring result.

## Declared source and file

| Handle | Declared file | Purpose |
|---|---|---|
| `forest_loss_history_1` | `source_assets/deforestation/<sample_id>/masks/lossyear.tif` | Hansen loss-year code per AOI pixel. |

The upstream product is
[Hansen/UMD Global Forest Change v1.13](https://developers.google.com/earth-engine/datasets/catalog/UMD_hansen_global_forest_change_2025_v1_13).
No annual event mask, `treecover2000`, optical, or SAR input is exposed or
read. All 96 declared references—the question JSON and one `lossyear.tif` per
record—exist inside the repository.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, forest_loss_history_1, role=hansen, time=2001_2023)` | Exact loss-year path and metadata; no event-year quality report is generated | `scene_1` |
| 2 | `PrepareScene(inputs={loss_history:scene_1}, mode=forest_loss_history)` | Input type, role, path status, and lineage | `work_1` |
| 3 | `ComputeStats(work_1, metrics={loss_area_ha_by_year:true}, region=aoi)` | Validates codes and computes the 2001–2023 area histogram | `stats_1` |
| 4 | `DetectChange(stats_1, change=largest_loss_year, window=2001_2023)` | Validates the statistics contract and returns the deterministic winner | `change_1` and final answer |
| 5 | `TaskComplete` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`DetectChange` consumes `stats_1` and performs no raw raster read. A `work_1`
input, wrong window/mode, malformed year, or non-positive/non-finite histogram
entry is rejected rather than recomputed or silently accepted.

## Calculation and decision contract

1. Read band 1 of the declared `lossyear.tif`. Exclude non-finite pixels and
   nodata 255; require at least one valid integer code in 0–25.
2. Analyze only codes 1–23, mapping them to 2001–2023. Code 0 is valid no loss;
   codes 24–25 are valid source values but outside this task's time window.
3. For each analyzed code, sum actual grid-cell areas. Geographic rasters use
   WGS84 ellipsoidal cell area; projected rasters use the affine determinant.
   Express hectares to six decimal places.
4. Select the largest six-decimal annual area. If multiple years are equal,
   choose the earliest calendar year.
5. If codes 1–23 are absent, return `year="no_loss"` and `loss_ha=0.0`. An
   all-nodata raster is an execution error, not `no_loss`.

## Final answer contract

```json
{
  "year": "integer 2001..2023 | no_loss",
  "loss_ha": 0.0
}
```

Both keys are required, `loss_ha` must be non-negative, and extra keys are
rejected. The JSON Schema permits only an integer in 2001–2023 or the exact
string `no_loss` for `year`.

## Edge cases and verified result

- Every raster has valid pixels; 13 contain no analyzed loss code and
  correctly return the nonempty `no_loss` object.
- Direct raster recomputation reproduces all 48 stored answers. No current
  maximum tie exists, but the generic earliest-year rule is published.
- The final detector preserves the source-derived six-decimal area.
- The focused replay passed 48/48 executions and 48/48 field-aware checks,
  with 192 nonempty artifacts and zero missing/outside paths.

**Validated contract.** The worker reads only the necessary
loss-year raster, validates its domain, returns a schema-valid exact winner,
and is causally tied to the preceding statistics result. The full regression
remains 2,921/2,921 for execution and field-aware validation across 43 types.

---

# Question type 7 of 43 — deforestation `cross_modal_concordance`

## Task and coverage

The agent compares whole-AOI Sentinel-2 vegetation-index change with
Sentinel-1 VH backscatter change and reports whether their binary indications
agree.

- Records: 48 AOIs — 43 train and 5 test.
- Classes: 11 `concordant`, 14 `discordant`, and 23 `no_change`.
- Every AOI has five Sentinel-1 acquisitions (two pre and three post).
- Optical coverage is five or six epochs, always with usable pre and post data.
- All 48 records have `training_weight=1.0`.

## What the agent must do and infer

**Do.** Open the optical and SAR handles, prepare one cross-modal context,
request their comparison, causally classify that comparison, and return the
class plus exact NDVI, contextual NBR, and VH evidence.

**Infer.** Apply the two independent threshold decisions and combine them:
both positive is `concordant`, exactly one positive is `discordant`, and
neither positive is `no_change`. NBR must be reported but does not determine
the class.

**Meaning in the benchmark.** This task measures sensor-fusion reasoning and
the ability to distinguish agreement from mere change. Optical vegetation
response and radar structural/backscatter response are complementary signals;
the benchmark tests whether the agent preserves their temporal conventions,
uses both, and follows a causal comparison-to-classification chain. The fixed
thresholds are operational benchmark proxies, not universal physical laws.

## Declared sources and files

| Handle | Declared files | Purpose |
|---|---|---|
| `optical_stack_1` | Five or six Sentinel-2 six-band GeoTIFFs plus matching RGB panels | Whole-AOI NDVI/NBR pre/post evidence and agent-visible context. |
| `sar_stack_1` | Five Sentinel-1 VV/VH GeoTIFFs with declared acquisition dates and pre/post roles | Whole-AOI VH pre/post change. |

The upstream products are
[Sentinel-2 L2A SR Harmonized](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR_HARMONIZED)
and
[Sentinel-1 GRD](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S1_GRD).
No Hansen mask is declared or read. All 822 declared path references exist
inside the repository; the public sidecar inventory lists only optical, SAR,
and SAR-window metadata.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, optical_stack_1, role=pre_post, time=event_window)` | Optical paths and temporal coverage | `scene_1` |
| 2 | `ReadData(question_1, sar_stack_1, role=pre_post, time=event_window)` | SAR paths, acquisition dates, and roles | `scene_2` |
| 3 | `PrepareScene(inputs={optical:scene_1, sar:scene_2}, mode=forest_cross_modal)` | Compatible inputs, path status, and lineage | `work_1` |
| 4 | `CompareSources(work_1, signals=ndvi_nbr_vs_vh, criterion=concordance)` | Finite whole-AOI evidence, thresholds, and preliminary class | `compare_1` |
| 5 | `ClassifyChange(compare_1, rule=concordance, labels=<three classes>)` | Verifies and formats only the preceding comparison | `class_1` and final answer |
| 6 | `TaskComplete` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ClassifyChange` accepts only the exact concordance comparison, verifies its
evidence, thresholds, and embedded class, performs zero raw reads, and rejects
`work_1` or any other incorrect causal handle.

## Calculation and decision contract

1. For each available optical epoch, compute AOI-valid-pixel NDVI and NBR.
   Each drop is the mean of available pre-epoch means minus the mean of
   available post-epoch means.
2. Aggregate Sentinel-1 VH in dB by each path's declared temporal role.
   `vh_delta_db = post_mean_db - pre_mean_db`.
3. Optical change is strictly `ndvi_drop > 0.10`; an exact 0.10 is false.
4. SAR change is strictly `vh_delta_db < -1.0`; an exact -1.0 dB is false.
5. Both true gives `concordant`; one true gives `discordant`; both false gives
   `no_change`. NBR is contextual evidence only.

All three evidence values must be numeric and finite. Missing temporal groups,
NaN, infinity, unsupported criteria, or inconsistent comparison content are
execution errors rather than `no_change` defaults.

## Final answer contract

```json
{
  "concordance": "concordant | discordant | no_change",
  "evidence": {
    "nbr_drop": 0.0,
    "ndvi_drop": 0.0,
    "vh_delta_db": 0.0
  }
}
```

The numbers illustrate types only. All fields are required, the class is
enum-constrained, values must be finite, and extra keys are rejected.

## Edge cases and verified result

- Explicit boundary tests cover exact and immediately adjacent threshold
  values for both worker stages.
- Direct raster recomputation exactly reproduces all 48 evidence objects and
  labels within the declared numerical tolerance.
- No record has missing/non-finite evidence or an empty required artifact.
- The focused replay passed 48/48 executions and field-aware checks, with 240
  nonempty artifacts and zero missing, absolute, or outside-root paths.

**Validated contract.** Inputs, temporal roles, equations,
threshold boundaries, schema, and causal handoff are explicit and consistent.
The repository-wide regression remains 2,921/2,921 across all 43 types.

---

# Question type 8 of 43 — deforestation `severity_proxy_numeric`

Population: **48 records** — 43 train and 5 public-reference test. Each record
has training weight 1.0.

## What the task asks and why

**Do.** Open only the Sentinel-1 pre/post stack, prepare its SAR-change
context, compute the whole-AOI VH change, score that numeric result, and return
the exact finite delta and one severity bucket.

**Infer.** Use every available acquisition according to its declared temporal
role. Compute `post_mean_db - pre_mean_db`, then apply the stated half-open
threshold intervals. The bucket must come from the computed number, not from a
filename, cached label, or unrelated optical/mask input.

**Meaning in the benchmark.** This task measures whether an agent preserves a
signed radar-change convention, passes a computed statistic causally into a
second worker, and handles numeric decision boundaries exactly. The four
buckets are operational benchmark proxies, not universal forest-severity
classes.

## Declared sources and files

| Handle | Declared files | Purpose |
|---|---|---|
| `sar_stack_1` | Five Sentinel-1 VV/VH GeoTIFFs, each with an acquisition date and `pre` or `post` role | Whole-AOI VH pre/post statistics. |

The upstream product is
[Sentinel-1 GRD](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S1_GRD).
No Sentinel-2 or Hansen file is declared or read. The 48 public sidecars expose
only `s1_grd` and `s1_window_metadata`; all 288 declared path references exist
inside the repository.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, sar_stack_1, role=pre_post, time=event_window)` | SAR paths, dates, roles, and availability | `scene_1` |
| 2 | `PrepareScene(inputs={sar:scene_1}, mode=sar_change)` | SAR context and lineage | `work_1` |
| 3 | `ComputeStats(work_1, metrics={vh_delta_db:true}, region=aoi)` | Declared-window whole-AOI VH delta | `stats_1` |
| 4 | `ScoreHazard(stats_1, hazard=forest_disturbance, scale=vh_delta_severity)` | Validates the exact upstream metric contract and applies the buckets | `score_1` and final answer |
| 5 | `TaskComplete` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ScoreHazard` accepts only the matching `stats_1` result carrying the declared
VH-delta measurement contract. It rejects `work_1`, a different metric result,
an unsupported hazard/scale, or missing/non-finite evidence; it never reopens
raw rasters or silently recomputes the preceding step.

## Calculation and decision contract

1. Group the five opened Sentinel-1 acquisitions by their declared `pre` and
   `post` roles; invented dates or inferred filename chronology are forbidden.
2. Compute valid-pixel AOI mean VH backscatter for each acquisition, then the
   mean for each temporal group.
3. Set `vh_delta_db = post_mean_db - pre_mean_db`.
4. Apply: severe if `< -3`; moderate if `-3 <= delta < -1`; mild if
   `-1 <= delta < 0`; none if `>= 0`.
5. Therefore exact `-3` is moderate, exact `-1` is mild, and exact `0` is none.

Both temporal groups must exist and the result must be numeric and finite.

## Final answer contract

```json
{
  "vh_delta_db": 0.0,
  "severity": "severe | moderate | mild | none"
}
```

The number illustrates the type only. Both fields are required, severity is
enum-constrained, and extra keys are rejected.

## Edge cases and verified result

- Direct source recomputation exactly reproduced all 48 numeric targets and
  buckets: 2 severe, 15 moderate, 18 mild, and 13 none.
- Explicit probes on both sides of each threshold and at `-3`, `-1`, and `0`
  produced the documented classes.
- No record has a missing temporal group, non-finite value, empty required
  artifact, missing path, or outside-root path.
- The focused replay passed 48/48 executions and field-aware checks with 192
  nonempty generated artifacts. The full regression remains 2,921/2,921.

**Validated contract.** The sole declared modality is sufficient,
the sign convention and boundaries are explicit, the chain is causal, and all
answers exactly match fresh computation.

---

# Question type 9 of 43 — multi-hazard wildfire `A`

All multi-hazard GeoTIFFs use the corresponding sample AOI as their spatial
contract. Source rasters are written on an EPSG:4326 grid derived from that
AOI; derived rasters preserve the reference grid. A release audit checks every
one of the 1,063 packaged raster/tabular GeoTIFFs across 108 samples for CRS,
AOI extent, and within-sample co-registration. A nominal `(0, 0)` origin is
invalid unless genuinely implied by the sample AOI. The current package has
zero failures.

Population: **15 records** — 13 train and 2 public-reference test. Each record
has training weight 1.0.

## What the task asks and why

**Do.** Open the wildfire measurement handle, prepare the scene, compute the
burned footprint area from the declared event mask, and return a complete JSON
answer containing the value, hectare units, source evidence, and completion
status.

**Infer.** Treat finite mask value 1 as burned and 0 as valid unburned. Sum the
actual grid-cell areas of the burned pixels and round once to three decimals;
do not estimate area from a nominal 500 m scale or from an image panel.

**Meaning in the benchmark.** This task tests direct quantitative extraction
from a source-specific hazard product, including nodata handling, geographic
cell area, source attribution, units, and final-answer assembly. It does not
ask the agent to classify burn severity.

## Declared sources and files

| Declared file | Purpose |
|---|---|
| `available_handles.json` | Confirms that the named cached source handle exists. |
| `rasters/mcd64a1__event.tif` | Binary event-window burned-area mask. |
| `rasters/mcd64a1__event.json` | Product provenance, source dates, units, shape, and raster checksum. |

The upstream source is NASA MODIS
[MCD64A1.061 Burned Area](https://developers.google.com/earth-engine/datasets/catalog/MODIS_061_MCD64A1),
whose `BurnDate` product was transformed during dataset construction into the
declared event-window binary mask. No dNBR, Sentinel-2, VIIRS, NIFC, panel,
population, OSM, GT, or trajectory file is exposed to this task. All 60 path
references across the 15 records are repository-relative, unique, and present.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, hazard_stack_1, role=wildfire, time=event)` | Exact handle inventory, MCD64 raster, and metadata paths | `scene_1` |
| 2 | `PrepareScene(inputs={hazard:scene_1}, mode=wildfire_burn)` | Wildfire context and declared-file lineage | `work_1` |
| 3 | `ComputeStats(work_1, metrics={burned_area:true}, region=aoi)` | Binary-mask validation, burned pixel count, grid-aware area, units, and source handle | `stats_1` and final answer |
| 4 | `TaskComplete(status=TASK_COMPLETE)` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ComputeStats` rejects a valid-but-wrong cross-domain metric such as
`forest_loss`, as well as invented metrics or the wrong region. It reads only
the three declared runtime dependencies and emits the area method and mask
contract; no sample ID or expected answer participates in the calculation.

## Calculation contract

1. Read the single-band MCD64 event mask and convert its declared finite
   nodata value to invalid pixels.
2. Require at least one valid pixel and require every valid value to be exactly
   0 or 1. Empty burned support is permitted in principle and would yield
   0.000 ha; an entirely invalid raster is an error.
3. Select valid pixels with value 1.
4. For EPSG:4326 grids, compute every selected cell's WGS84 ellipsoidal area;
   for a projected grid, use the affine determinant with CRS unit conversion.
5. Sum in hectares and round the final area to three decimal places.

## Final answer contract

```json
{
  "status": "TASK_COMPLETE",
  "answer": {
    "value": 0.0,
    "units": "ha"
  },
  "evidence": {
    "primary_area_ha": 0.0,
    "primary_handle": "mcd64a1__event"
  }
}
```

The numbers illustrate types only. `answer.value` and `primary_area_ha` must
agree, both must be non-negative, the status/units/handle strings are fixed by
schema, and extra keys are rejected. The runtime projects this object from
`stats_1` plus the literal terminal status; it never copies a stored answer.

## Edge cases and verified result

- All 15 rasters have valid binary 0/1 support, matching declared SHA-256
  hashes, and nonempty burn masks. Fresh areas exactly match all 15 targets.
- Areas span 548.919–23,052.567 ha; no NaN, infinity, empty analytical result,
  missing dependency, or fallback estimate occurs.
- All 108 multi-hazard A records pass their domain-specific metric contracts;
  wildfire A passes 15/15 field-aware checks and produces 45 nonempty replay
  artifacts. The independent 20-type multi-hazard logic audit reports zero
  undeclared or missing runtime dependencies.
- The full regression remains 2,921/2,921 and all 43 field-aware types pass.

**Validated contract.** The prompt, declared files, binary-mask
semantics, grid-area calculation, worker output, schema, and targets are
explicitly aligned.

---

# Question type 10 of 43 — multi-hazard wildfire `B`

Population: **15 records** — 13 train and 2 public-reference test. Each record
has training weight 1.0.

## What the task asks and why

**Do.** Open the dNBR and MCD64 inputs, prepare the wildfire scene, classify
valid dNBR pixels only inside the MCD64 burned footprint, and return the
dominant class/fraction plus complete per-class evidence.

**Infer.** Apply the four declared half-open dNBR intervals, count the valid
masked population, select the class with the largest count, and divide that
count by the complete classified population. Respect exact boundaries and the
declared tie order.

**Meaning in the benchmark.** This task tests masked categorical reasoning:
the agent must distinguish a source-defined analysis footprint from a
continuous severity index, preserve class-boundary semantics, and synthesize
a structured answer from worker evidence. The bins are an operational burn
severity convention, not a field-validated damage assessment.

## Declared sources and files

| Declared file | Purpose |
|---|---|
| `available_handles.json` | Confirms both cached handles. |
| `rasters/dnbr.tif` and `.json` | Sentinel-2 pre-minus-post NBR change and its provenance/grid metadata. |
| `rasters/mcd64a1__event.tif` and `.json` | Binary MCD64 event burn footprint and metadata. |

The upstream inputs are
[Sentinel-2 L2A SR Harmonized](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR_HARMONIZED)
and NASA MODIS
[MCD64A1.061 Burned Area](https://developers.google.com/earth-engine/datasets/catalog/MODIS_061_MCD64A1).
No Landsat, VIIRS, NIFC, panel, exposure, GT, or trajectory file is exposed.
All 90 path references across these records are relative, unique, and present.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, hazard_stack_1, role=wildfire, time=event)` | Exact dNBR/MCD64 paths and metadata | `scene_1` |
| 2 | `PrepareScene(inputs={hazard:scene_1}, mode=wildfire_burn)` | Wildfire context and declared-file lineage | `work_1` |
| 3 | `ScoreHazard(work_1, hazard=wildfire, scale=question_defined_class)` | Masked class table, dominant class/fraction, counts, areas, and means | `score_1` and final answer |
| 4 | `TaskComplete(status=TASK_COMPLETE)` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`ScoreHazard` binds `question_defined_class` to B questions. It rejects the D
task's `impact_footprint` scale, another domain, an invented scale, or an empty
analysis population. The class worker verifies that the class counts exactly
partition every finite dNBR pixel inside the MCD64 footprint.

## Classification contract

1. Select finite dNBR pixels where the finite binary MCD64 mask equals 1.
2. Assign unburned for dNBR `< 0.10`, low for `0.10 <= dNBR < 0.27`,
   moderate for `0.27 <= dNBR < 0.44`, and high for `dNBR >= 0.44`.
3. For each class, report pixel count, six-decimal mean dNBR (or null for a
   possible empty class), and three-decimal grid-aware area in hectares.
4. Choose the largest pixel count. An exact tie selects the first class in
   order: unburned, low, moderate, high.
5. `dominant_fraction = dominant_count / all classified valid pixels`, rounded
   to six decimals. `mask_pixel_count` separately describes the MCD64 mask.

## Final answer contract

```json
{
  "status": "TASK_COMPLETE",
  "answer": {
    "class": "unburned | low | moderate | high",
    "dominant_fraction": 0.0
  },
  "evidence": {
    "dominant_class": "unburned | low | moderate | high",
    "by_class": {
      "unburned": {"area_ha": 0.0, "pixel_count": 0, "mean_value": null},
      "low": {"area_ha": 0.0, "pixel_count": 0, "mean_value": null},
      "moderate": {"area_ha": 0.0, "pixel_count": 0, "mean_value": null},
      "high": {"area_ha": 0.0, "pixel_count": 0, "mean_value": null}
    },
    "analysis_scope": "mcd64_burn_footprint",
    "mask_pixel_count": 1
  }
}
```

The numbers illustrate types only. The class strings are enum-constrained,
fraction is in `[0,1]`, counts/areas are non-negative, class and
`dominant_class` must agree, and extra keys are rejected.

## Edge cases and verified result

- Fresh worker/source computation exactly reproduces all 15 complete answers.
  Dominant labels are 2 unburned, 2 low, 0 moderate, and 11 high; the absent
  dominant-moderate outcome is population evidence, not an unreachable class.
- Boundary probes immediately below and at 0.10, 0.27, and 0.44 produce the
  declared bins. A four-way equal-count probe selects unburned.
- Every current class row is nonempty. Footprints contain 385–15,679 pixels and
  dominant fractions range from 0.285139 to 0.538427.
- All 108 multi-hazard B records, the 2,921-record regression, and all 43
  field-aware type checks pass with zero worker or input-path errors.

**Validated contract.** Inputs, masking, thresholds, denominator,
tie behavior, area/mean evidence, schema, and targets are explicit and aligned.

---

# Question type 11 of 43 — multi-hazard wildfire `C`

Population: **15 records** — 13 train and 2 public-reference test. Each record
has training weight 1.0.

## What the task asks and why

**Do.** Open three declared, co-registered binary footprints—MCD64A1 burned
area, fixed-threshold Sentinel-2 dNBR support, and the NIFC incident
perimeter—measure each footprint, and decide whether their areas agree.

**Infer.** Compute all three symmetric pairwise area differences, take their
median, and compare it with the fixed 20% limit. Return the source areas and
all pairwise evidence needed to inspect that decision.

**Meaning in the benchmark.** This tests multi-source reconciliation. The
agent must distinguish source agreement from source truth: agreement means
that three operational footprints have similar mapped areas under the stated
rule, not that they are spatially identical or that any product is perfect.

## Declared sources and files

| Declared file | Purpose |
|---|---|
| `available_handles.json` | Verifies the exact cached comparison handles. |
| `rasters/mcd64a1__event.tif` and `.json` | Binary MODIS burned-area footprint and provenance/grid metadata. |
| `rasters/s2_burn_support.tif` and `.json` | Binary support derived by applying dNBR `>=0.10`; the sidecar records the derivation. |
| `rasters/nifc_perimeter__event.tif` and `.json` | Exact incident polygon rasterized on the common grid, plus provider/selection provenance. |

The first `ReadData` handle carries only the inventory; the second carries the
six analytical files. No RGB, Landsat, VIIRS, panel, AOI, exposure, GT, or
trajectory artifact is exposed. All 120 references are relative, unique,
present, and inside the repository. The upstream products are NASA MODIS
MCD64A1, Sentinel-2 L2A SR Harmonized, and the NIFC WFIGS Interagency Fire
Perimeters cited in `ATTRIBUTIONS.md`.

## Required causal tool sequence

| Step | Call | What it validates or computes | Output used by |
|---:|---|---|---|
| 1 | `ReadData(question_1, hazard_stack_1, role=wildfire, time=event)` | Handle inventory and wildfire context | `scene_1` |
| 2 | `ReadData(question_1, agreement_sources_1, role=wildfire, sources=all)` | Three masks and sidecars | `scene_2` |
| 3 | `PrepareScene(inputs={hazard:scene_1,sources:scene_2}, mode=multisource_hazard)` | Exact causal lineage and input readiness | `work_1` |
| 4 | `CompareSources(work_1, sources=all, criterion=area_agreement, maximum_median_pct_delta=20.0)` | Areas, decision, score, and spatial support statistics | `compare_1` and final answer |
| 5 | `TaskComplete(status=TASK_COMPLETE)` | Closes the specialist subgoal; carries no terminal answer | ORC termination by published answer reference |

`CompareSources` accepts only a type-C `multisource_hazard` work artifact with
the three declared raster/sidecar pairs. It rejects another criterion,
threshold, work type, missing lineage, non-binary wildfire mask, empty common
valid population, or mismatched grid.

## Agreement contract

1. Validate finite wildfire mask values as binary and require identical shape,
   CRS, and affine transform.
2. Sum actual grid-cell areas where each mask is 1. Geographic grids use WGS84
   ellipsoidal cell areas; projected grids use the affine determinant.
3. For every source pair compute
   `abs(A-B) / ((A+B)/2) * 100`; two zero areas have difference 0.
4. The decision statistic is the median of the three pairwise percentages.
   `median_pct_delta <= 20.0` means `sources_agree`; larger values mean
   `sources_disagree`.
5. `agreement_score_0_100 = max(0, 100 - median_pct_delta)`. Compute from
   unrounded source areas and round emitted area/percentage/score values to
   three decimals.
6. IoU, full binary-state agreement, and Cohen's kappa use common valid cells
   only. They are support statistics and do not silently alter the area verdict.

The final JSON requires the decision, metric, median area/difference, bounded
score, all three source areas, all three pairwise area differences, and all
three sets of spatial support statistics. Metric, verdict, score contract, status,
numeric ranges, and object keys are schema-constrained.

## Edge cases and verified result

- All 45 TIFF/sidecar checksum pairs match; every mask is nonempty, binary,
  AOI-aligned, and co-registered.
- Fresh computation reproduces all 15 complete targets: 11 agree and 4
  disagree. Median differences span 2.858–63.742%; scores span 36.258–97.142.
- A boundary probe agrees at exactly 15.317% and disagrees when the limit is
  lowered to 15.316%, confirming inclusive threshold behavior.
- The model-facing observation exposes the score contract, three source
  areas, and every pairwise field required by the final schema.
- Focused execution and field-aware checks pass 15/15; all 40 adversarial
  argument/causal-input mutations are rejected for the intended reason.

**Validated contract.** The inputs, georeferencing, binary-mask
semantics, exact area calculation, decision rule, support statistics, worker
lineage, schema, and stored answers are aligned.

---

# Question type 12 of 43 — multi-hazard wildfire `D`

Population: **15 records** — 13 train and 2 public-reference test.

**Agent task.** Count distinct cached OSM highway-feature representative
points within an inclusive 5 km of the binary MCD64A1 burn footprint. Use the
actual GeoJSON geometry, transform it and the burn-cell centers into a local
azimuthal-equidistant metric CRS, and return the count with footprint,
population, in-footprint, nearest-feature, and method evidence.

**Agent inference.** Treat each declared OSM feature as one representative
point and use authoritative GeoJSON coordinates. The output is determined by
the inclusive metric distance to positive burn-cell centers, not cached
row/column hints, road length, or network connectivity.

**Benchmark meaning.** This tests raster/vector integration and metric
distance reasoning. The output counts one representative point per cached OSM
feature; it is not road length, intersection count, accessibility, or damage.

The seven declared paths are the question JSON, `available_handles.json`, the
MCD64A1 TIFF/sidecar, WorldPop TIFF/sidecar, and `osm/pois.geojson`. No panel,
unrelated wildfire raster, AOI, GT, or trajectory is exposed. The chain is
`ReadData` (wildfire), `ReadData` (highways), `PrepareScene`,
`ScoreHazard(scale=impact_footprint)`, `EstimateExposure(within_km=5)`, and
`TaskComplete`.

The GeoJSON coordinates are authoritative; cached `row`/`col` properties are
not. `in_footprint` is calculated by transforming the representative geometry
through the raster CRS and affine transform. The 5,000 m comparison is
inclusive and uses the unrounded nearest cell-center distance. Points outside
the AOI can count only when they exist in the declared cache and fall inside
that buffer. WorldPop must match the footprint's shape, CRS, and transform and
contain no negative values; it supplies supporting population evidence but
does not affect the highway count.

The 15 primary counts are **48–249**. Authoritative GeoJSON geometry determines
all auxiliary `in_footprint` values; cached row/column hints are
non-authoritative. Nearest distances span 1.951–21.115 m. Focused execution and
field-aware validation pass 15/15, all outputs are finite and nonempty, and
43/43 adversarial calls are rejected. The worker also requires a nonempty
wildfire type-D impact score and the complete declared
raster/population/OSM lineage. The shared geometry audit independently checks
all 20,927 cached OSM geometries and all 157 D-task in-footprint evidence
values with zero mismatches. Valid zero-pixel drought and air footprints are
accepted as measured zero-exposure outcomes rather than mistaken for failures.

**Validated contract.** Geometry authority, grid alignment,
distance boundary, proxy interpretation, causal chain, schema, and answers
are explicit and consistent.

---

# Question type 13 of 43 — multi-hazard deforestation `A`

Population: **23 records** — 21 train and 2 public-reference test.

**Agent task.** Open the declared Hansen event mask, prepare the forest-loss
scene, compute the area of pixels whose loss year equals 2022, and return the
three-decimal hectare value with the source handle.

**Agent inference.** The agent must infer the AOI's 2022 loss area from the
worker's measured binary footprint; it must not substitute all-years loss,
canopy area, an alert product, or an image-panel estimate.

**Benchmark meaning.** This tests source/temporal selection, causal tool use,
binary-mask interpretation, nodata handling, and grid-aware geospatial area
measurement on a second provider/domain contract.

The four declared paths are the question JSON, `available_handles.json`, and
the `hansen_loss__event` TIFF/sidecar. The sidecar identifies Hansen Global
Forest Change 2025 v1.13 with `lossyear=2022`; its checksum matches the TIFF in
all 23 samples. Unused Sentinel-2, RADD, TMF, panel, and AOI paths are not
exposed to this task.

The fixed chain is `ReadData(role=deforestation,time=event)`,
`PrepareScene(mode=forest_loss)`,
`ComputeStats(metrics={forest_loss:true},region=aoi)`, and `TaskComplete`.
`ComputeStats` accepts only the causal type-A prepared-work handle, the exact
domain metric, and the declared primary TIFF, sidecar, and inventory lineage.
It rejects a scene handle or cross-domain metric.

Finite mask value 1 means Hansen loss year 2022; 0 means valid no-2022-loss.
Declared nodata/non-finite cells are excluded. Geographic cell areas are
summed on the WGS84 ellipsoid (projected grids use the affine determinant),
then rounded once to 0.001 ha. The answer schema fixes `units="ha"`,
`primary_handle="hansen_loss__event"`, nonnegative areas, and
`status="TASK_COMPLETE"`. The build sidecar discloses that source-masked
binary cells were filled with 0. This cannot create positive loss and gives
the same positive-mask numerator as excluding those cells.

Independent raster/checksum recomputation matches every stored target. Each
mask has 16,384 valid pixels and 56–767 positive pixels; answers span
107.692–1,449.402 ha. All 23 outputs are positive and finite. Cross-domain
type-A replay and field-aware validation pass 108/108, and all 43 adversarial
argument/causal-input probes are rejected for the intended reason.

**Validated contract.** The event year, provider handle, declared
inputs, causal sequence, binary/nodata semantics, exact area method, schema,
and all 23 answers are aligned.

---

# Question type 14 of 43 — multi-hazard deforestation `B`

Population: **23 records** — 21 train and 2 public-reference test.

**Agent task.** Open the Hansen 2022 loss mask and Sentinel-2 NDVI-change
raster, prepare the forest-loss scene, classify every finite NDVI-drop pixel
inside the loss footprint, and return the pixel-count-dominant class and its
fraction with complete per-class evidence.

**Agent inference.** The agent must distinguish the dominant NDVI-drop bin
inside a known loss footprint. A result of `none` means the majority has a
drop below 0.15; it does not contradict the Hansen loss observation.

**Benchmark meaning.** This tests masked raster classification, temporal-index
sign interpretation, boundary rules, grid co-registration, causal tool use,
and evidence-based answer assembly.

The six declared paths are the question JSON, handle inventory, and the
`hansen_loss__event` and `ndvi_change` TIFF/sidecar pairs. The change sidecar
defines the value as Sentinel-2 NDVI pre minus post. Unused RADD, TMF,
pre/post component rasters, panels, and AOI files are not exposed.

The chain is `ReadData`, `PrepareScene(mode=forest_loss)`,
`ScoreHazard(hazard=deforestation,scale=question_defined_class)`, and
`TaskComplete`. The scorer accepts only the causal type-B prepared work and
declared files. It requires the two rasters to have identical shape, CRS, and
affine transform and rejects a scene handle, wrong hazard, scale, or lineage.

Classification uses lower-inclusive, upper-exclusive bins: `none`
`[-10,0.15)`, `minor` `[0.15,0.30)`, `major` `[0.30,0.50)`, and `severe`
`[0.50,10)`. Every finite NDVI value at a finite Hansen-1 pixel must fall in
exactly one bin. Dominance uses pixel count; an exact tie follows the declared
none/minor/major/severe order. Per-class areas use exact grid-cell areas, and
rounding occurs only on emitted fields.

Independent raster and checksum recomputation reproduces every answer and all
evidence fields. All 23 dominant classes are `none`, with fractions
0.670360–1.000000. This is a real threshold outcome, not an empty-mask
fallback: masks contain 56–767 pixels, 20 samples contain minor pixels, 17
contain major pixels, and 6 contain severe pixels. No dominant tie occurs.
All 432 multi-hazard chains and 20/20 field-aware types pass, and 43/43
adversarial probes are rejected for the intended reason.

**Validated contract.** The NDVI sign, Hansen mask, thresholds,
boundary/tie rules, grid alignment, causal chain, schema, and all 23 outputs
are explicit and independently consistent.

---

# Question type 15 of 43 — multi-hazard deforestation `C`

Population: **23 records** — 21 train and 2 public-reference test.

**Agent task.** Open three declared, co-registered 2022 forest-disturbance
masks; compute each footprint's exact area and the three symmetric pairwise
area differences; apply the declared 25% median-difference threshold; and
return the decision, bounded score, source areas, and spatial support statistics.

**Agent inference.** The agent must infer whether Hansen annual loss, JRC TMF
annual loss, and RADD event-window alerts agree closely enough in footprint
area. It must not treat zero alerts as missing data, compare rounded display
areas, or substitute spatial overlap for the declared area verdict.

**Benchmark meaning.** This tests explicit temporal/source semantics,
multi-source raster comparison, exact geospatial area calculation, robust
aggregation, and structured evidence assembly. Agreement is an operational
benchmark rule, not a claim that one product is ground truth.

The eight declared paths are the question JSON, `available_handles.json`, and
the TIFF/sidecar pairs for `hansen_loss__event`, `tmf_loss__event`, and
`radd_alerts__event`. Their checksums and temporal metadata are verified. The
first mask is finite binary Hansen `lossyear=2022`; the second is finite binary
JRC TMF change where December 2022 is deforested and December 2021 is not; the
third uses `0=no alert`, `1=low confidence`, and `2=high confidence` for RADD
alerts dated 2022-06-01 through 2022-09-30. Values above zero form the RADD
footprint. Unused panels, AOI files, and unrelated rasters are not exposed.

The chain is two `ReadData` calls, `PrepareScene(mode=multisource)`,
`CompareSources(metric=area_agreement,maximum_median_pct_delta=25.0)`, and
`TaskComplete`. The comparison worker reads only declared lineage, validates
the allowed mask values and exact shape/CRS/affine co-registration, and fails
on an all-nodata source or grid mismatch.

For source areas `A` and `B`, each pairwise percentage is
`abs(A-B)/((A+B)/2)*100`; it is zero when both areas are zero. The verdict uses
the median of the three unrounded percentages: at or below 25% means
`sources_agree`; above 25% means `sources_disagree`. The bounded score is
`max(0,100-median_pct_delta)`. Emitted areas and percentages are rounded to
three decimals. IoU, binary-state agreement, and Cohen's kappa use common
valid cells and are support statistics; they do not alter the area verdict.
`TaskComplete.status` is `TASK_COMPLETE` for either verdict because source
disagreement is a successfully computed answer, not a contract failure.

Independent rasterio/PyProj recomputation reproduces all source areas,
pairwise fields, support statistics, scores, and verdicts for 23/23 records. All 23
are `sources_disagree`; median differences span 48.008–200.000% and scores
0.000–51.992. Hansen and TMF areas are positive in every record. Nine RADD
masks have a valid measured zero-alert footprint; the files still contain a
valid grid and finite observations, so this is neither empty output nor a
fallback. All 23 focused outputs have complete direct answer support, the
full 2,921-record replay and field-aware audit pass, and no declared input is
missing or outside the repository.

**Validated contract.** Temporal windows, source encodings,
georeferencing, co-registration, zero-event semantics, exact area formula,
threshold, support statistics, causal chain, schema, and stored answers are aligned.

---

# Question type 16 of 43 — multi-hazard deforestation `D`

Population: **23 records** — 21 train and 2 public-reference test.

**Agent task.** Measure the distance from the Hansen 2022 loss footprint to
the nearest distinct cached OSM highway-feature representative point, or
return an explicit unavailable state when no highway representative is
cached. Also return the fixed 5 km context count, in-footprint count, nearest
name, footprint area, and WorldPop footprint sum.

**Agent inference.** The agent must distinguish a measured distance from the
valid no-feature state. It must use authoritative GeoJSON geometry and the
current loss mask, not cached row/column hints, an AOI centroid, a rendered
panel, or a road-line distance that the point-based cache cannot support.

**Benchmark meaning.** This tests causal raster/vector exposure analysis,
coordinate transformation, metric nearest-neighbour reasoning, null-state
handling, and honest interpretation of cached OSM representatives. It does
not claim road-network access, road length, or field-verified infrastructure.

The seven declared paths are the question JSON, `available_handles.json`, the
Hansen `hansen_loss__event` TIFF/sidecar, WorldPop TIFF/sidecar, and
`osm/pois.geojson`. Panels, AOI files, alternate loss products, and unrelated
rasters are not exposed. The chain is two `ReadData` calls,
`PrepareScene(mode=forest_loss_exposure)`,
`ScoreHazard(scale=impact_footprint)`,
`EstimateExposure(exposure=nearest_highway)`, and `TaskComplete`.

Finite Hansen value 1 is a 2022 loss cell and 0 is valid no loss. The worker
requires a binary raster and exact WorldPop shape/CRS/affine co-registration.
It transforms every raster-cell center and authoritative GeoJSON
representative point into an AOI-centered azimuthal-equidistant CRS. Distance
is the minimum point-to-positive-cell-center distance. Therefore a point
located inside a positive raster cell can have a small nonzero cell-center
distance; `in_footprint` separately records affine cell membership. The 5,000
m context boundary is inclusive. Counts are per distinct cached OSM feature.

Twenty records contain a cached highway representative and return finite
distances from 14.648 to 4,136.076 m. Three contain none and consistently
return `availability_status=no_cached_highway_representative`, null answer
distance, null nearest name/distance, and zero highway counts. Six samples
have at least one representative in a positive loss cell. These are valid
source outcomes, not empty outputs.

An independent geometry audit reproduces all 157 multi-hazard D-task
in-footprint counts, 5 km counts, nearest names, and distances from the source
rasters and GeoJSON. It also verifies all 1,063 multi-hazard GeoTIFF grids and
20,927 cached OSM features. Focused and repository-wide replay use only the
seven declared inputs. `EstimateExposure` emits the generically derived
availability status alongside its nearest-feature evidence, and all 23 records
have complete field-level worker support.

**Validated contract.** Source semantics, binary/nodata handling,
geometry authority, projection, cell-center distance interpretation, buffer
boundary, null state, causal lineage, schema, and all 23 answers are aligned.

---

# Question type 17 of 43 — multi-hazard urban expansion `A`

Population: **29 records** — 27 train and 2 public-reference test.

**Agent task.** Open the declared Dynamic World built-gain mask, prepare the
urban-change scene, measure its exact area, and return hectares with the
source handle.

**Agent inference.** The agent must identify new built probability between the
2019 and 2024 annual composites, rather than reporting total built cover,
negative change, an NDBI proxy, or another provider's time window.

**Benchmark meaning.** This tests source and temporal selection, derived-mask
interpretation, exact geospatial area measurement, causal tool use, and strict
answer assembly.

The four declared paths are the question JSON, `available_handles.json`, and
the `built_gain` TIFF/sidecar. The mask is derived from Dynamic World
`GOOGLE/DYNAMICWORLD/V1`: post-2024 built probability above 0.55 and pre-2019
built probability at or below 0.55. The annual composite windows are
2019-01-01–2020-01-01 and 2024-01-01–2025-01-01. Unused NDBI, GHSL,
WorldCover, component rasters, panels, and AOI files are not exposed.

The chain is `ReadData(role=urban_expansion,time=event)`,
`PrepareScene(mode=built_up_gain)`,
`ComputeStats(metrics={built_up_gain:true},region=aoi)`, and `TaskComplete`.
The statistics worker accepts only the matching causal Type-A work handle,
metric, and declared TIFF/sidecar/inventory lineage. It requires a finite
binary 0/1 mask. Geographic grids use WGS84 ellipsoidal cell areas; projected
grids use their affine determinant; final hectares are rounded to three
decimals.

Independent reconstruction from every pre/post Dynamic World pair exactly
matches all 29 packaged gain masks, grids, and checksums. Independent area
summation reproduces every stored answer, spanning 177.428–5,104.218 ha. All
29 outputs are finite and positive, focused evidence support is 29/29, and
the full replay plus field-aware audit pass.

**Validated contract.** Provider, composite windows, threshold
direction, derived pixels, binary validation, area method, causal lineage,
schema, declared inputs, and all 29 answers are aligned.

---

# Question type 18 of 43 — multi-hazard urban expansion `B`

Population: **29 records** — 27 train and 2 public-reference test.

**Agent task.** Classify every finite whole-AOI Sentinel-2 NDBI-change pixel,
then return the pixel-count-dominant change class, its fraction, and complete
per-class counts, exact areas, and means.

**Agent inference.** The agent must preserve the signed `NDBI_2024 −
NDBI_2019` direction. Negative change represents contraction and must never be
reported as positive urban growth.

**Benchmark meaning.** This tests temporal-index sign reasoning, exhaustive
raster classification, interval boundaries, dominance/tie handling, causal
tool use, and structured evidence assembly.

The four declared paths are the question JSON, handle inventory, and
`ndbi_change` TIFF/sidecar. Component NDBI rasters, built-gain products,
panels, AOI, GHSL, and WorldCover files are not runtime inputs. The chain is
`ReadData`, `PrepareScene(mode=built_up_gain)`,
`ScoreHazard(hazard=urban_expansion,scale=question_defined_class)`, and
`TaskComplete`.

The complete lower-inclusive, upper-exclusive bins are contraction
`[-10,-0.02)`, stable `[-0.02,0.02)`, minor `[0.02,0.18)`, and major
`[0.18,10)`. Dominance uses pixel count; exact ties follow that declared
order. Per-class areas use exact grid-cell areas. Every finite AOI pixel must
fall in exactly one class.

Independent reconstruction verifies all 29 change rasters equal their
Sentinel-2 post-minus-pre inputs. The stored results reproduce exactly: 15
contraction, 12 minor, and 2 stable dominant cases; no major-dominant case is
manufactured. Focused execution and complete evidence support pass 29/29.

**Validated contract.** Change direction, scope, thresholds,
coverage, area method, tie rule, causal lineage, schema, files, and answers
are aligned.

---

# Question type 19 of 43 — multi-hazard urban expansion `C`

Population: **29 records** — 27 train and 2 public-reference test.

**Agent task.** Compare three source-native built-gain masks, calculate exact
areas and symmetric pairwise differences, apply the fixed 30% median rule,
and return the decision, bounded score, source areas, and spatial support statistics.

**Agent inference.** The agent must decide operational area agreement while
recognizing that Dynamic World 2019–2024, GHSL 2020–2025, and WorldCover
2020–2021 measure different epochs and product constructs. Disagreement is a
valid scientific outcome, not failed execution.

**Benchmark meaning.** This tests heterogeneous-source semantics, robust
three-source comparison, exact area calculation, support-statistic separation, and
complete structured synthesis.

The eight declared paths are the question, handle inventory, and three
TIFF/sidecar pairs: `built_gain`, `ghsl_built_gain`, and
`worldcover_built_gain`. Every mask is independently reconstructed from its
provider-native pre/post inputs and is binary, checksum-valid, and exactly
co-registered. Unrelated indices, panels, and AOI files are excluded.

The tool sequence is `ReadData` for the hazard inventory, `ReadData` for all
three agreement sources, `PrepareScene(mode=multisource_hazard)`,
`CompareSources(criterion=area_agreement, maximum_median_pct_delta=30.0)`, and
`TaskComplete`.

The three symmetric differences use
`abs(A-B)/((A+B)/2)*100`, with zero for two zero areas. The median of the
unrounded differences is compared inclusively with 30%; the score is
`max(0,100-median)`. IoU, state agreement, and kappa use common valid pixels
but do not alter the area verdict.

All stored evidence recomputes exactly. There are 28 disagreements and one
agreement; median differences span 18.893–174.701% and bounded scores
0–81.107. The published population therefore contains 28 disagreements and
one agreement under the declared source products and threshold.
Focused execution and full evidence support pass 29/29.

**Validated contract.** Source epochs, gain definitions,
co-registration, formulas, decision threshold, support statistics, chain, schema,
and all answers are aligned.

---

# Question type 20 of 43 — multi-hazard urban expansion `D`

Population: **29 records** — 27 train and 2 public-reference test.

**Agent task.** Use the binary Dynamic World 2019–2024 built-gain footprint
to sum co-registered WorldPop 2020 people-per-pixel values, then return that
population with footprint area and cached hospital/school representative-point
context.

**Agent inference.** The returned number is population located inside newly
built cells at the WorldPop reference epoch. It is not a causal estimate of
population growth or people added by urban expansion. The agent must preserve
that distinction when selecting the exposure operation and formatting the
answer.

**Benchmark meaning.** This tests raster-mask exposure estimation, temporal
and source interpretation, exact grid alignment, vector/raster spatial
context, causal tool routing, and strict structured synthesis.

The seven declared paths are the question, handle inventory, `built_gain`
TIFF/sidecar, WorldPop 2020 TIFF/metadata, and one authoritative cached OSM
GeoJSON. Unused NDBI, GHSL, WorldCover, panels, AOI files, and intermediate
rasters are excluded. The chain is two `ReadData` calls,
`PrepareScene(mode=built_up_gain_exposure)`,
`ScoreHazard(hazard=urban_expansion,scale=impact_footprint)`,
`EstimateExposure(exposure=population_in_footprint)`, and `TaskComplete`.

The worker requires exact shape, CRS, and affine co-registration; validates a
binary gain mask; sums only non-negative WorldPop count values where the mask
equals 1; and computes footprint area from exact grid-cell areas. Hospital and
school membership uses authoritative GeoJSON representative points mapped to
positive cells. Inclusive 5 km context and nearest cell-center distances use a
local azimuthal-equidistant CRS. Cached row/column hints are never geometry
authority.

Independent source recomputation exactly reproduces all 29 population values,
footprint areas, in-footprint counts, 5 km counts, nearest names, and distances.
Population spans 51.108–612,394.383 people; zero hospital or school counts are
valid measured outcomes, not missing data. Focused execution and complete
evidence support pass 29/29, and all required artifacts are nonempty.

**Validated contract.** Source meaning, epoch interpretation,
mask semantics, grid alignment, geometry, exposure sum, causal lineage,
schema, declared inputs, and all answers are aligned.

---

# Question type 21 of 43 — multi-hazard drought `A`

Population: **21 records** — 18 train and 3 public-reference test.

**Agent task.** Open the declared MODIS NDVI target raster and six-observation
same-season baseline, compute the target AOI mean and its z-score, and return
that value with units and baseline mean.

**Agent inference.** The agent must distinguish a spatial target statistic
from its temporal reference distribution. The target is the arithmetic mean
of finite pixels in the actual `modis_ndvi__target` GeoTIFF; the comparison
mean and sample standard deviation come only from the six non-target baseline
rows.

**Benchmark meaning.** This tests source selection, spatial aggregation,
temporal-standardization reasoning, causal tool use, and exact numeric answer
assembly without treating a cached scalar as a substitute for the raster.

The five declared paths are the question, handle inventory, MODIS NDVI target
TIFF/sidecar, and `baselines/modis_ndvi_anomaly.csv`. Other drought sources,
derived masks, panels, and AOI files are not inputs to this task. The chain is
`ReadData(role=drought,time=event)`,
`PrepareScene(mode=drought_anomaly)`,
`ComputeStats(metrics={ndvi_z_score:true},region=aoi)`, and `TaskComplete`.

The worker requires a single-band target with at least one finite pixel and
NDVI in `[-1,1]`, exactly one dated target marker and at least two historical
observations, and a finite positive baseline sample standard deviation. With
six baseline values, it computes `mean`, `std(ddof=1)`, and
`z=(target_AOI_mean-baseline_mean)/std`; final values are rounded to six
decimals. The CSV target row mirrors the raster mean for auditability, but the
worker calculates the target from the GeoTIFF.

Independent Rasterio/NumPy recomputation reproduces all 21 answers. Final
z-scores span -0.226802–3.313451, all target rasters have finite data, and
focused execution plus complete evidence support pass 21/21.

**Validated contract.** The target raster is computational,
baseline membership is explicit, the formula and ddof are fixed, validation
rejects empty/nonfinite inputs, the chain is causal, and all answers match
independent source computation.

---

# Question type 22 of 43 — multi-hazard drought `B`

Population: **21 records** — 18 train and 3 public-reference test.

**Agent task.** Classify every finite CHIRPS same-window SPI pixel into the
declared train-relative quartile intervals, then return the pixel-count
dominant class, fraction, and complete per-class counts, areas, and means.

**Agent inference.** The four labels describe the position of a pixel in this
benchmark's training distribution. `q1_low_spi` is relatively low within that
fit; none of the labels is a universal drought-severity category.

**Benchmark meaning.** This tests leakage-safe normalization selection,
continuous-raster classification, interval boundaries, dominance/tie logic,
exact geospatial area evidence, and structured synthesis.

The five declared paths are the question, handle inventory, CHIRPS SPI
TIFF/sidecar, and `drought_normalization.json`. Other drought rasters, masks,
panels, and AOI files are excluded. The chain is `ReadData`,
`PrepareScene(mode=drought_anomaly)`,
`ScoreHazard(hazard=drought,scale=question_defined_class)`, and
`TaskComplete`.

The normalization fit contains all 294,912 finite pixels from the 18 training
AOIs and excludes the three test AOIs. Recomputed quartile
boundaries are exactly -0.1381913721561432, 0.6701323390007019, and
1.3935534954071045. The four intervals are lower-inclusive and
upper-exclusive with open numerical coverage extended to ±1e30. Dominance
uses pixel count and exact ties use q1-to-q4 declaration order. Areas use
WGS84 ellipsoidal cells.

Independent split/quantile reconstruction and raster classification reproduce
every target: 3 q1, 4 q2, 8 q3, and 6
q4 dominant cases. Every record classifies all 16,384 finite pixels; focused
execution and complete evidence support pass 21/21.

**Validated contract.** Fit membership, test isolation,
thresholds, interval coverage, interpretation, dominance, exact areas,
lineage, schema, files, and answers are aligned.

---

# Question type 23 of 43 — multi-hazard drought `C`

Population: **21 records** — 18 train and 3 public-reference test.

**Agent task.** Derive one low-state mask from each co-registered CHIRPS SPI,
MODIS NDVI, and ERA5 soil-moisture raster using its training-pixel q25; compute
all three pairwise IoUs; and decide whether their median reaches 0.30.

**Agent inference.** Agreement concerns spatial overlap between three
source-specific, benchmark-relative low states. It does not compare raw units,
claim that q25 means universal severe drought, or treat a scientifically valid
disagreement as tool failure.

**Benchmark meaning.** This tests multi-source normalization, thresholded mask
construction, co-registration, spatial agreement, leakage-safe evidence use,
and complete structured decision synthesis.

The nine declared paths are the question, handle inventory, train-only
normalization contract, and three TIFF/sidecar pairs. The hazard handle carries
the fit contract; the source handle carries the continuous rasters, avoiding
duplicate declarations. The chain is two `ReadData` calls,
`PrepareScene(mode=multisource_hazard)`,
`CompareSources(criterion=iou,minimum_iou=0.3,
threshold_contract=per_source_train_pixel_q25_v1,
normalization_fit_split=train)`, and `TaskComplete`.

Each threshold exactly reproduces from 294,912 finite training pixels per
source. A source mask is `value < q25`; pairwise IoU uses common valid,
co-registered cells. Two empty masks have IoU 1 by the declared set rule. The
decision is the median of the three six-decimal pairwise IoUs, inclusive at
0.30. Exact source-mask areas are evidence but do not change the decision.

Independent Rasterio/NumPy/PyProj reconstruction reproduces every threshold,
mask area, pairwise IoU, score, and verdict. All 21 medians are honestly 0 and
all 21 verdicts are `sources_disagree`; nine CHIRPS and twelve ERA5 AOI masks
are valid measured-zero masks, while no MODIS mask is empty. The class balance
is therefore 21 `sources_disagree` cases under the declared sources and rule.
The worker emits all nine contract fields, and focused full-answer support
passes 21/21.

**Validated contract.** Training fit, source thresholds, grid
alignment, empty-mask rule, IoU aggregation, interpretation, worker evidence,
lineage, schema, files, and answers are aligned.

---

# Question type 24 of 43 — multi-hazard drought `D`

Population: **21 records** — 18 train and 3 public-reference test.

**Agent task.** Count cached OSM school representative points whose
authoritative geometry falls in a positive cell of the declared low-CHIRPS-SPI
footprint, and return the count with footprint and exposure context.

**Agent inference.** The footprint is a prepared binary representation of
`CHIRPS SPI < training-pixel q25`. The primary answer is a representative-point
count, not a count of school polygons, students, buildings, or nearby schools.

**Benchmark meaning.** This tests derived-footprint interpretation,
vector/raster spatial membership, empty-footprint handling, causal exposure
routing, and exact structured synthesis.

The seven declared paths are the question, handle inventory, `low_chirps_spi`
TIFF/sidecar, WorldPop TIFF/metadata, and authoritative cached OSM GeoJSON.
The binary sidecar records the train-only threshold provenance; the runtime
task consumes the prepared mask rather than redundantly rereading raw CHIRPS.
The chain is two `ReadData` calls,
`PrepareScene(mode=drought_anomaly_exposure)`,
`ScoreHazard(hazard=drought,scale=impact_footprint)`,
`EstimateExposure(exposure=schools)`, and `TaskComplete`.

Independent reconstruction verifies every binary mask against its raw CHIRPS
raster and stored training q25. School membership uses authoritative GeoJSON
representative points transformed into the footprint grid. The 5 km context
and nearest distance use a local azimuthal-equidistant CRS and positive cell
centers. WorldPop is exactly co-registered supporting evidence. Cached
row/column hints are not geometry authority.

Nine footprints are valid measured-zero masks, yielding zero area, population,
school count, buffer count, and null nearest context as appropriate. Nineteen
records contain zero schools in the footprint and two contain three; this
source-driven imbalance is retained. All 21 answers reproduce, focused
execution/support pass 21/21, and the independent 157-case multi-hazard D
geometry audit reproduces every count and distance.

**Validated contract.** Mask derivation, zero-mask semantics,
geometry authority, membership, distance, population context, causal lineage,
schema, files, and all answers are aligned. The binary-mask chain reads no
undeclared normalization file.

---

# Question type 25 of 43 — multi-hazard air pollution `A`

Population: **20 records** — 18 train and 2 public-reference test.

**Agent task.** Compute the maximum and 95th percentile of finite pixels in
the declared Sentinel-5P episode-peak tropospheric NO2 raster, then return the
maximum in µmol/m² with both statistics as evidence.

**Agent inference.** The raster already stores each pixel's maximum over the
declared episode. The requested answer is the spatial maximum of that temporal
peak composite—not a surface concentration, health category, or live reading.

**Benchmark meaning.** This tests product/unit interpretation, two-stage
spatiotemporal statistic reasoning, declared-raster computation, causal tool
use, and precise numeric synthesis.

The four declared paths are the question, handle inventory, and
`s5p_no2__peak` TIFF/sidecar. Other pollutants, derived masks, normalization,
panels, and AOI files are excluded. The chain is `ReadData`,
`PrepareScene(mode=pollution_peak)`,
`ComputeStats(metrics={peak_no2_column:true},region=aoi)`, and
`TaskComplete`.

The source is Sentinel-5P OFFL/L3 tropospheric NO2 column number density,
scaled by 1e6 from mol/m² to µmol/m². The worker rejects missing declared
dependencies and an empty finite population. It computes NumPy-compatible
maximum and percentile statistics and rounds to six decimals.

Independent hash, Rasterio, and NumPy checks reproduce all 20 answers and p95
values exactly. Peaks span 113.555962–412.991425 µmol/m²; every raster is
finite and nonempty. Focused execution plus complete evidence support pass
20/20.

**Validated contract.** Product identity, temporal/spatial
meaning, units, finite-data handling, statistics, causal lineage, schema,
declared inputs, and all answers are aligned.

---

# Question type 26 of 43 — multi-hazard air pollution `B`

Population: **20 records** — 18 train and 2 public-reference test.

**Agent task.** Classify every finite pixel of the Sentinel-5P episode-peak
tropospheric NO2-column raster into the declared training-relative quartile
intervals, then return the pixel-count dominant class, fraction, and complete
per-class counts, areas, and means.

**Agent inference.** The four labels locate pixels within this benchmark's
training distribution. They are not WHO categories, surface concentrations,
health-risk classes, or live pollution assessments.

**Benchmark meaning.** This tests leakage-safe normalization selection,
continuous-raster classification, interval boundaries, dominance/tie logic,
geospatial area evidence, and structured synthesis.

The five declared paths are the question, handle inventory, Sentinel-5P
TIFF/sidecar, and `normalization.json`. Other pollutants, derived masks,
panels, and AOI files are excluded. The chain is `ReadData`,
`PrepareScene(mode=pollution_peak)`,
`ScoreHazard(hazard=air_pollution,scale=benchmark_relative_column_quartile)`,
and `TaskComplete`.

The normalization was fitted only on all 294,912 finite pixels from the 18
training AOIs; neither test AOI contributed. Recomputed quartile boundaries
are exactly 88.19622039794922, 121.34806823730469, and
179.93792724609375 µmol/m². Intervals are lower-inclusive and upper-exclusive
with numerical coverage extended to ±1e30. Dominance uses pixel count and an
exact tie uses q1-to-q4 declaration order. Areas use WGS84 ellipsoidal cells.

Independent Rasterio/NumPy reconstruction reproduces all thresholds and all
20 expected answers. Dominant results are 5 q1, 5
q2, 6 q3, and 4 q4; all 16,384 pixels in every AOI are finite and classified.
The worker emits the benchmark-specific train-only fit contract, and complete
evidence support passes 20/20.

**Validated contract.** Training membership, test isolation,
thresholds, units, interval coverage, interpretation, dominance, areas,
lineage, schema, files, worker evidence, and all answers are aligned.

---

# Question type 27 of 43 — multi-hazard air pollution `C`

Population: **20 records** — 18 train and 2 public-reference test.

**Agent task.** Compute each source's finite-pixel AOI mean for Sentinel-5P
NO2 column, CAMS NO2 column, and MODIS AOD; standardize each mean against that
source's training-AOI distribution; assign one of three relative states; and
report whether all three sources occupy the same state.

**Agent inference.** Agreement means agreement in within-product relative
episode intensity. It does not mean equal physical values, interchangeable
pollutants, pixelwise spatial correlation, or health-risk agreement.

**Benchmark meaning.** This tests heterogeneous-source interpretation,
leakage-safe per-source normalization, unit-aware evidence, categorical
aggregation, causal tool use, and complete structured synthesis.

The nine declared paths are the question, handle inventory, train-only
normalization contract, and three TIFF/sidecar pairs. Panels and unrelated
pollutants are excluded. The chain is two `ReadData` calls,
`PrepareScene(mode=multisource_hazard)`,
`CompareSources(criterion=benchmark_relative_intensity_agreement,
required_agreement_fraction=1.0,normalization_fit_split=train)`, and
`TaskComplete`.

For each source, z is `(AOI mean - mean of 18 training AOI means) / population
standard deviation of those 18 means`. Values below -0.5 are
`below_training_typical`, values above 0.5 are `above_training_typical`, and
the inclusive middle is `training_typical`. Agreement fraction is the largest
state count divided by three; the required 1.0 means all sources must match.
Test AOIs never enter the fit.

Independent Rasterio/NumPy reconstruction reproduces all training means and
population standard deviations, then every source mean, z-score, state,
fraction, and verdict. Four records agree and 16 disagree; fractions are 1.0
for 4, 0.666667 for 7, and 0.333333 for 9. The worker rejects a non-train fit or
agreement threshold other than 1.0. Focused execution/support pass 20/20.

**Validated contract.** Product meanings, differing units,
finite-pixel summaries, training-only normalization, state boundaries,
decision rule, worker arguments, lineage, schema, files, and all answers are
aligned.

---

# Question type 28 of 43 — multi-hazard air pollution `D`

Population: **20 records** — 18 train and 2 public-reference test.

**Agent task.** Use the declared binary top-quartile Sentinel-5P NO2-column
footprint, sum co-registered WorldPop people-per-pixel values inside it, and
return that population with footprint area and cached hospital/school context.

**Agent inference.** The answer is population geographically located in a
benchmark-relative high-column footprint at the WorldPop 2020 reference
epoch. It is not exposed-person causality, surface concentration, health risk,
or a live population estimate.

**Benchmark meaning.** This tests prepared-mask provenance, inclusive
threshold boundaries, raster/raster aggregation, vector/raster membership,
valid zero-footprint handling, and causal exposure routing.

The seven declared paths are the question, handle inventory,
`high_no2_column` TIFF/sidecar, WorldPop TIFF/metadata, and authoritative
cached OSM GeoJSON. The sidecar carries the training threshold provenance, so
the runtime consumes the prepared footprint without an undeclared raw-raster
read. The chain is two `ReadData` calls,
`PrepareScene(mode=pollution_peak_exposure)`,
`ScoreHazard(hazard=air_pollution,scale=impact_footprint)`,
`EstimateExposure(exposure=high_no2_column_population)`, and `TaskComplete`.

Independent reconstruction verifies every mask as finite
`s5p_no2__peak >= training-pixel q75`, where q75 is
179.93792724609375 µmol/m² and the lower q4 boundary is inclusive. WorldPop
must match shape, CRS, and affine transform and contain no negative values.
OSM membership uses each authoritative geometry's representative point;
5 km context and nearest distance use a local azimuthal-equidistant CRS and
positive cell centers.

Twelve footprints are valid measured-zero masks, so their population, area,
asset counts, and nearest values are zero/null as defined—not missing output.
Across the other eight cases, population reaches 711,292.703 and footprint
area reaches 26,228.546 ha. All expected answers reproduce. The exposure
worker emits the required `train_only_s5p_pixel_q75_v1` provenance field, and
binary-mask scoring performs no undeclared normalization read.
Focused execution/support pass 20/20; the independent 157-case multi-hazard D
geometry audit passes all counts and distances.

**Validated contract.** Train-only threshold provenance,
inclusive boundary, zero-mask semantics, grid alignment, population sum,
geometry authority, distances, worker output, lineage, schema, files, and all
answers are aligned.

---

# Question type 29 of 43 — xBD damage `XBD-Q1`

Population: **177 records** — 160 train and 17 public-reference test.

**Agent task.** Open the post-disaster scene and its declared xBD building
polygons, compute counts by damage class, classified-only damaged and severe
percentages, and total severe-building footprint area.

**Agent inference.** Severe means `major-damage` or `destroyed`. Unclassified
polygons count toward `total_buildings` but not percentage denominators;
polygon labels and geometry—not visual guessing from the PNG—are authoritative.

**Benchmark meaning.** This tests causal multimodal routing, categorical
aggregation, denominator discipline, polygon-area computation, and exact
structured reporting.

The two declared paths are the post-disaster PNG and
`building_damage_xy.geojson`. The chain is two `ReadData` calls,
`PrepareScene(mode=xbd_damage)`, `AssessDamage(aggregation=scene)`,
`ComputeStats` on `damage_1`, and `TaskComplete`. `ComputeStats` consumes the
causal damage artifact; it does not reread a hidden target.

The five normalized classes are `no-damage`, `minor-damage`, `major-damage`,
`destroyed`, and `unclassified`. Damaged count is minor+major+destroyed;
severe count is major+destroyed. Both percentages divide by the four-class
classified count and return 0 only if that denominator is zero. Severe area
is polygon pixel-coordinate area multiplied by the scene GSD squared, summed
and rounded to four decimals. Source coordinates are retained for scene-level
area; the separate frame-clipping rule belongs only to quadrant tasks.

Independent source-first geometry recomputation matches all 177 answers.
Sixty scenes contain unclassified buildings, confirming that the denominator
rule is exercised; no scene has zero classified buildings. Severe counts
range 0–271, and 56 scenes validly report zero severe area. Focused execution
and complete evidence support pass 177/177. The schema bounds counts/area at
zero and percentages at 0–100.

**Validated contract.** Source authority, label normalization,
class definitions, denominators, area method, causal handles, schema, files,
and every expected answer are aligned.

---

# Question type 30 of 43 — xBD damage `XBD-Q2`

Population: **177 records** — 160 train and 17 public-reference test.

**Agent task.** Rank the four 2×2 frame quadrants by severe polygon area
clipped to each quadrant, select the ascending-ID representative of an exact
maximum-area tie, and report that quadrant's centroid-assigned severe-building
count and clipped severe area.

**Agent inference.** Area is spatially divisible across boundaries, while a
building count is indivisible and belongs to its centroid quadrant. The count
and area therefore need not describe the same set of whole polygons.

**Benchmark meaning.** This tests prepared spatial summaries, object-versus-
area aggregation, clipping semantics, deterministic ranking, tie handling,
causal artifact use, and exact synthesis.

The two declared paths are the post-disaster PNG and `quadrants.geojson`.
That table is a source-derived cache independently checked against the xBD
polygons. The chain is two `ReadData` calls,
`PrepareScene(mode=xbd_quadrants,grid=2x2)`,
`AssessDamage(aggregation=quadrant_2x2,severity=severe)`,
`RankRegions(by=severe_footprint_area_m2,top_k=1)`, and `TaskComplete`.

The frame is clipped at x/y 0, 512, and 1024. Severe classes are major and
destroyed. Ranking uses unrounded clipped square-metre area; exact ties select
the lexicographically ascending Q0–Q3 ID only as the reported representative.
In a zero-severe scene all four areas tie at zero, so Q0 with count/area zero
is the defined result.

Independent polygon clipping reproduces all 177 targets. It finds 146 severe
polygons crossing quadrant boundaries in 53 scenes; using centroid area
instead would change the winner in two scenes, confirming that the declared
rule is material. Fifty-six zero-severe scenes exercise the all-zero tie.
Focused execution and complete evidence support pass 177/177. Schema values
are constrained to Q0–Q3 and nonnegative count/area.

**Validated contract.** Frame/clipping coordinates, severe-class
definition, mixed count/area semantics, ranking, exact ties, zero state,
causal handles, schema, files, and every answer are aligned.

---

# Question type 31 of 43 — xBD damage `XBD-Q3`

Population: **177 records** — 160 train and 17 public-reference test.

**Agent task.** Rank eligible cells in the prepared 4×4 grid by the exact
classified-building severity fraction, return the ascending-ID representative
of the exact top tie, all tied IDs, the top three eligible cells, and complete
winner/count/status evidence.

**Agent inference.** The score is
`(minor + 2×major + 3×destroyed)/(3×classified)`. Unclassified buildings do
not enter the denominator; a cell with no classified buildings has no score
and cannot win, even if its cached display score is zero.

**Benchmark meaning.** This tests formula interpretation, undefined-versus-
zero handling, exact rational ranking before display rounding, full tie
reporting, top-k behavior, and structured synthesis from a causal artifact.

The two declared paths are the post-disaster PNG and `grid_4x4.geojson`.
The prepared table is independently reconstructed from the polygon source.
The chain is two `ReadData` calls, `PrepareScene(mode=xbd_grid,grid=4x4)`,
`AssessDamage(aggregation=grid_4x4)`,
`RankRegions(by=normalized_damage_severity,top_k=3)`, and `TaskComplete`.

Ranking uses exact integer fractions, descending, then ascending cell ID.
`severity_score` is only the six-decimal display value. `top_tied_cell_ids`
contains every exact top tie, while `top_k_cells` contains the first three
ranked eligible cells. A future scene with no eligible cell has null winner
and score, an empty top list, and status `no_classified_buildings`.

Independent source-first recomputation matches all 177 answers, representative
winners, tie sets, and top-three rows. Across the scenes, 1,089 cells are
excluded for lacking classified buildings, including 30 all-unclassified
cells; 90 records exercise an exact top tie, with as many as 16 tied cells.
Every current scene still has at least one eligible cell. Focused execution and
complete evidence support pass 177/177. Schema bounds preserve both current
and defined future branches.

**Validated contract.** Formula, classified denominator,
eligibility, exact ranking, display rounding, ties, top-k, no-eligible branch,
causal handles, schema, files, and all answers are aligned.

---

# Question type 32 of 43 — xBD damage `XBD-Q4`

Population: **55 records**, each a unique same-event scene pair — 49 train and
6 public-reference test.

**Agent task.** Compute a complete polygon-derived damage summary for each
scene, compare classified-only severe percentages and severe footprint areas
separately, and report each metric's unique winner or exact tie set.

**Agent inference.** Percentage and area answer different questions and may
have different winners. A tied metric has every tied scene ID, a null singular
winner, and status `tie`; the agent must not choose an arbitrary representative.

**Benchmark meaning.** This tests multi-scene handle routing, denominator
discipline, two-criterion comparison, exact tie/null semantics, and structured
synthesis across causal analytical stages.

The four declared paths are each scene's post-disaster PNG and xBD polygon
GeoJSON. All pairs are unique, unordered same-event pairs and remain wholly in
one split. The chain is two `ReadData` calls,
`PrepareScene(mode=scene_compare)`,
`AssessDamage(aggregation=pair_compare,severity=severe)`,
`CompareScenes(by=severe_damage_ratio_and_footprint)`, and `TaskComplete`.

For each scene, severe percentage is `100 × (major+destroyed) / classified`,
rounded to two decimals; unclassified polygons remain in totals but not the
denominator. A future zero-classified scene emits 0.0 with status
`no_classified_buildings` and is excluded from percentage ranking. Area uses
the unrounded sum of severe polygon areas. Comparisons use emitted numeric
values and preserve all exact top ties.

Independent polygon/GSD recomputation matches both summaries, both winners,
tie lists, and statuses for all 55 pairs. Every current scene is percentage-
eligible. Forty-nine pairs have unique winners for each metric; six pairs tie
on both and correctly return null winner fields. Focused execution and
complete evidence support pass 55/55. Schema bounds cover counts,
percentages, areas, and 0–2-item tie lists.

**Validated contract.** Pair identity/split isolation, class and
denominator rules, polygon areas, independent comparison axes, zero-
denominator policy, exact ties/nulls, causal handles, schema, files, and all
answers are aligned.

---

# Question type 33 of 43 — xBD damage `XBD-Q5`

Population: **121 records** — 109 train and 12 public-reference test.

**Agent task.** Extract exactly the major-damage and destroyed building
polygons, then report their count, combined footprint area, separate
major/destroyed areas, source, filter, and area method.

**Agent inference.** “Severe” is the union of two explicit xBD label classes,
not a new visual classification. A scene with no qualifying polygon returns a
complete zero-valued result, not an empty object or failed extraction.

**Benchmark meaning.** This tests metadata-bound question interpretation,
object filtering, causal handle passage from extraction to assessment,
polygon/GSD area aggregation, zero-object handling, and exact synthesis.

The two declared paths are the post-disaster PNG and
`building_damage_xy.geojson`. The chain is two `ReadData` calls,
`PrepareScene(mode=xbd_damage)`,
`ExtractObjects(target=severe_buildings,severity=major_or_destroyed)`,
`AssessDamage(work=objects_1,aggregation=severe_only)`, and `TaskComplete`.
The final assessment consumes the extraction artifact rather than bypassing
the declared causal step.

Each polygon area is its pixel-coordinate geometry area multiplied by the
scene GSD squared. Major and destroyed areas are summed independently and
their sum is the combined severe area, rounded to four decimals. Counts are
whole qualifying polygons; unclassified, no-damage, and minor-damage polygons
are excluded.

Independent source-first recomputation matches all 121 counts and all three
areas. Thirty-nine records validly contain zero severe polygons and return a
complete seven-field result with zero count/areas. Focused execution and full
evidence support pass 121/121. Every Q5 prompt derives the disaster type and
event from its declared scene metadata.

**Validated contract.** Prompt/scene identity, severe filter,
causal extraction, polygon source, GSD area calculation, per-class sum,
zero-object behavior, schema, files, and all answers are aligned.

---

# Question type 34 of 43 — xBD damage `XBD-Q7`

Population: **121 records** — 109 train and 12 public-reference test.

**Agent task.** Count severe-building centroids in each 2×2 quadrant, rank
all four quadrants, compute maximum-count concentration, classify its spatial
pattern, and return the full distribution and exact maximum tie set.

**Agent inference.** Concentration is `max quadrant severe count / total
severe count`. When total severe is zero the ratio is undefined, so the score
and worst quadrant are null and the top-tie list is empty—not four tied zeros.

**Benchmark meaning.** This tests causal multi-stage aggregation, spatial
count concentration, threshold classification, exact ties, null/zero
distinction, and structured answer synthesis.

The two declared paths are the post-disaster PNG and `quadrants.geojson`.
The chain is two `ReadData` calls,
`PrepareScene(mode=xbd_quadrants,grid=2x2)`,
`AssessDamage(aggregation=quadrant_2x2,severity=major_or_destroyed)`,
`RankRegions(by=severe_damage_count,top_k=4)`,
`ScoreHazard(work=rank_1,scale=spatial_concentration)`, and `TaskComplete`.
The scorer consumes the ranked artifact and cannot bypass it with `work_1`.

For a positive total, scores at least 0.70 are highly concentrated, scores at
least 0.45 and below 0.70 are moderately concentrated, and lower scores are
spatially dispersed. Exact maximum ties emit every tied ID; the ascending ID
is only the representative `worst_quadrant`, with `tie_break_applied=true`.

Independent centroid-count reconstruction reproduces all 121 distributions,
scores, classes, ties, and representatives. Coverage is 36 highly
concentrated, 26 moderately concentrated, 20 dispersed, and 39
`no_severe_damage`; four scored records exercise a maximum tie. All 39 zero
cases have null score/winner and empty tie list. Focused execution and complete
evidence support pass 121/121. Schema constraints bind grid, counts, score
range, quadrants, and the null branch.

**Validated contract.** Severe definition, centroid assignment,
concentration formula, thresholds, exact ties, zero/null state, causal handles,
schema, files, and every answer are aligned.

---

# Question type 35 of 43 — xBD damage `XBD-Q8`

Population: **177 records** — 160 train and 17 public-reference test.

**Agent task.** Produce one comprehensive scene report from the declared xBD
building polygons, 2×2 quadrant table, and target mask: damage counts and
percentages, footprint areas, severe-damage concentration, and raster/polygon
class-presence validation.

**Agent inference.** Polygon labels are authoritative for building counts and
areas. The target mask is an independent rasterized validation view: mask
classes 3+4 count severe *pixels*, not buildings. Therefore the valid
cross-source check compares whether each damage class is present, while exact
pixel histograms and polygon counts remain separate quantities.

**Benchmark meaning.** This tests a multimodal four-input join, nested answer
synthesis, classified-only denominator policy, polygon/GSD area computation,
spatial concentration, raster-code interpretation, and explicit cross-source
validation without conflating objects with pixels.

The four declared paths are the post-disaster PNG,
`building_damage_xy.geojson`, `quadrants.geojson`, and `post_target.png`. The
chain calls `ReadData` for `image_1`, `damage_labels_1`, and `mask_layers_1`;
the last handle contains both quadrant and target-mask paths. It then calls
`PrepareScene(mode=xbd_scene_summary)`, `AssessDamage(aggregation=scene)`, and
`ComputeStats(metrics=damage_summary,target_mask_distribution,severe_footprint_area)`,
before `TaskComplete`. Every runtime read resolves from those opened handles.

Severe percentage uses classified buildings only. Severe polygon area uses
pixel-coordinate geometry multiplied by GSD squared. Concentration uses the
largest quadrant severe-centroid count divided by total severe count; its
zero-severe branch returns null score, null worst quadrant, and no tied IDs.
The 1024×1024 mask permits only codes 0–4, so every stored histogram sums to
1,048,576 pixels. Unclassified polygons are intentionally excluded because
the target encoding has no unclassified class. `class_presence_consistent`
means polygon and raster sources agree on whether each class occurs; it does
not assert equal object and pixel counts.

Independent reads of the declared assets reproduce all 177 polygon summaries,
all 177 mask histograms, and every severe-pixel total; all class-presence checks
are consistent. Fifty-six scenes validly exercise the complete zero-severe
branch. Focused execution and complete answer evidence pass 177/177, with 708
declared path references present and repository-relative. Capture date is not
reported because the question does not ask for it and no declared input is an
authoritative capture-date source. The public schema binds methods, encodings,
ranges, class names, and null states explicitly.

**Validated contract.** Input roles, denominators, areas,
concentration, zero/null behavior, mask encoding, polygon/raster semantics,
schema, paths, and all answers are aligned.

---

# Question type 36 of 43 — routing `nearest_shelter`

Population: **200 records** — 180 train and 20 public-reference test.

**Agent task.** Validate the supplied flood-screened route candidates against
the declared road-edge costs, select the minimum fastest-objective candidate,
and report its attached shelter, confidence, route ID, distance, ETA,
length-weighted flood risk, objective cost, and blocked-edge count.

**Agent inference.** `nearest_shelter` is a backward-compatible type name. The
agent is not given a new universe of shelters and must not claim a fresh
spatial nearest-neighbour or road-graph search. It validates the packaged F
candidate group and reports the shelter attached to its computed winner.

**Benchmark meaning.** This tests precise scope reading, causal use of
flood-exposure evidence, independent validation of a cached geospatial product,
constrained candidate selection, metadata reporting, and resistance to
overclaiming what the inputs prove.

The seven declared paths are Sentinel-2 RGB GeoTIFF/preview, metadata,
Copernicus flood extent, OSM-derived flood-risk roads, candidate-route
geometries, and route scores. The chain is `ReadData`,
`PrepareScene(mode=flood_safe_routing)`,
`EstimateExposure(exposure=blocked_roads)`, then
`PlanRoutes(objective=nearest_reachable_shelter,
avoid.flood_affected_roads=true)` consuming `exposure_1`, followed by
`TaskComplete`.

The worker decomposes each route geometry into its declared road edges and
recomputes distance, ETA, node count, blocked-edge count, length-weighted risk,
and objective cost. Fastest cost is summed `travel_time_min`; only candidates
with zero blocked edges are eligible, with ETA, distance, and route ID as
deterministic tie-breakers. The selected shelter fields must match metadata.
Confidence is copied from declared metadata: 187/200 scenes carry the
`low_fallback_public_facility` label. This is a benchmark candidate-validation
task, not official evacuation guidance.

Independent source-first audit reproduces all 1,800 route metric sets from
454,968 road edges and verifies the fastest winner, unblocked state, origin,
common endpoint, shelter metadata, and expected Type 36 answer in all 200
scenes. Focused execution and complete answer evidence pass 200/200; all 1,400
path references are present and repository-relative. Six argument-sensitivity
tests confirm that invalid objectives, unscreened requests, and invalid render
layer combinations are rejected. The schema requires a nonempty answer and
`terminated=true`.

**Validated contract.** Inputs,
blocked-road evidence, metric formulas, selection, causal handles, shelter
metadata, confidence disclosure, answer synthesis, schema, and paths align.

---

# Question type 37 of 43 — routing `fastest_safest`

Population: **200 records** — 180 train and 20 public-reference test.

**Agent task.** Validate all supplied route candidates, select the minimum-cost
candidate within the fastest, safest-weighted, and balanced groups, report all
three, and quantify the safest-versus-fastest distance, ETA, and mean-risk
trade-off without inventing an evacuation recommendation.

**Agent inference.** “Safest-weighted” is a named composite objective, not a
claim that the selected route has the smallest displayed mean risk. The agent
must apply the declared edge-cost formula and distinguish selection cost from
the descriptive length-weighted risk statistic.

**Benchmark meaning.** This tests validation of cached route products,
multi-objective reasoning, formula fidelity, comparison-handle dataflow,
zero-versus-positive trade-offs, and disciplined reporting under a declared
safety scope.

The same seven repository-relative routing inputs are used. The chain is
`ReadData`, `PrepareScene(mode=flood_safe_routing)`,
`PlanRoutes(objective=candidate_routes,
avoid.flood_affected_roads=true)`, and `CompareRoutes` consuming `routes_1`
with fastest, safest, and balanced preferences enabled, then `TaskComplete`.

For each route geometry, the worker reconstructs source road edges and checks
all metrics. Fastest cost is `sum(travel_time_min)`, safest-weighted cost is
`sum(travel_time_min * (1 + 10*flood_risk))`, and balanced cost uses multiplier
4. Eligibility requires zero blocked edges; objective cost, ETA, distance, and
route ID define deterministic selection. Deltas are S1 minus F1 for distance
and ETA and F1 minus S1 for displayed mean risk.

Independent audit validates every F1/S1/B1 winner and all 1,800 candidate
metric sets. S1 is also the minimum raw-risk S candidate in only 27/200 scenes,
demonstrating why the composite-objective wording matters. In 144 scenes the
rank-one strategies share a geometry and correctly report a zero trade-off;
the remaining 56 have larger S1 distance/ETA and lower displayed mean risk.
Focused execution and complete answer evidence pass 200/200, with all 1,400
path references present. The worker emits no recommendation, performs no
runtime graph search, and rejects partial/invalid preference contracts. The
schema requires a nonempty answer and `terminated=true`.

**Validated contract.** Candidate
validation, objective formulas, eligibility, selections, deltas, zero cases,
causal handles, safety wording, schema, files, and all answers align.

---

# Question type 38 of 43 — routing `visual_overlay`

Population: **200 records** — 180 train and 20 public-reference test.

**Agent task.** Validate and compare the packaged route candidates, render a
fresh overlay from the declared RGB, road, flood, route, and metadata inputs,
then return the image marker and schema-fixed render-validation receipt.

**Agent inference.** The requested image must be newly derived from the current
`route_compare_1` handle. A prepared overlay is not an allowed
shortcut. A zero visible count for a source layer is valid when the declared
feature set has no in-chip member; the agent must not manufacture content.

**Benchmark meaning.** This tests causal artifact generation, multi-layer CRS
alignment, deterministic visualization, image-plus-JSON output, provenance,
and the distinction between actually rendering evidence and retrieving a
cached final answer.

The same seven routing inputs are declared; no prepared overlay PNG is on the
input card. The chain is `ReadData`, `PrepareScene`,
`PlanRoutes(objective=overlay_routes)`, `CompareRoutes` over all three
objectives, then `RenderMap(work=route_compare_1,style=route_overlay)` with
RGB, roads, flood, blocked roads, origin, shelter, routes, and labels enabled,
followed by `TaskComplete`.

The renderer reads the GeoTIFF CRS and affine transform, converts WGS84 vector
coordinates into that CRS, and applies the inverse raster transform to obtain
pixels. It does not use a synthetic `from_origin(0, ...)` transform. It
validates the current F1/S1/B1 selections, all nine route geometries and labels,
both point markers, nonempty bytes, and changed RGB pixels, and writes a PNG
plus JSON manifest inside the current run artifact directory.

The final answer is a structured receipt directly backed by worker fields:
`<image>`, existence, render contract, `prepared_overlay_used=false`, current
handle, selected IDs, requested layers, rendered route/label IDs, origin and
shelter flags, 912×512 dimensions, and termination.

Focused execution has complete answer evidence for 200/200. Independent
artifact inspection opens all 200 PNGs/manifests with zero errors; byte sizes
range from 499,654 to 696,682 and changed chip pixels from 4,452 to 131,737.
All 200 image hashes reproduce exactly across separate runs. Five scenes
validly render zero in-chip risky roads and 20 render zero blocked roads; all
still contain flood pixels, ordinary roads, nine routes/labels, and markers.
All 1,400 declared path references exist and remain repository-relative.

**Validated contract.** Current-handle causality, real
georeferencing, declared inputs, layer toggles, rendered content, determinism,
artifact storage, structured gold, schema, files, and all outputs align.

---

# Question type 39 of 43 — Sen1Floods11 `A`

Population: **100 records** — 90 train and 10 public-reference test.

**Agent task.** Derive a flood-prediction mask from the declared Sentinel-1
VV/VH raster and report predicted flood percentage and exact-grid area,
8-neighbour component count, largest-component area/centroid, and the complete
4×4 spatial inventory.

**Agent inference.** These are properties of a deterministic SAR-derived
prediction, not claims that every predicted pixel is true flood. Hand labels
are evaluator-only and must not be used to create the answer. The valid
empty-prediction branch returns zero measurements and no largest centroid; it must
never fall back to a label or cached target.

**Benchmark meaning.** This tests raster loading, finite/nodata handling,
deterministic thresholding, generated-artifact lineage, connected components,
geodesic measurement, spatial aggregation, and honest prediction semantics.

The sole declared data path is the chip's `S1Portable.tif`, a finite-nodata
derivative of the official Sen1Floods11 two-band Sentinel-1 input. The chain is
`ReadData`, `PrepareScene(mode=sar_flood)`,
`MapFlood(method=s1_min_backscatter_otsu_v1)`,
`ExtractObjects(target=flood_components)`, `DescribeFlood` consuming
`objects_1` with percentage/area/components/4×4 metrics, then `TaskComplete`.

The predictor uses pixels finite and non-nodata in both VV and VH, calculates
`min(VV,VH)`, applies a 256-bin Otsu threshold, and marks scores at or below the
threshold as predicted flood. It writes a run-scoped uint8 mask with 0 valid
non-flood, 1 predicted flood, and 255 nodata. Components use 8-neighbour
connectivity. Area is summed from WGS84 ellipsoidal cell areas; centroids are
means of positive pixel-center coordinates. The 4×4 grid reports valid/flood
pixels, within-cell percentage, and share of total predicted flood.

Independent source and execution audit covers all 100 rasters: they are
512×512, two-band VV/VH, EPSG:4326, float32, nodata `-9999`, with no duplicate
source hashes and no material train/test spatial overlap. Recomputed
8-neighbour counts match 100/100; ellipsoidal area differs from worker output
by at most 0.000493 m² before three-decimal rounding. No prediction in the
release is empty; flood coverage spans 0.3638–67.83638% and component counts
31–4,138.
Focused execution and complete answer evidence pass 100/100, all 100 input
paths exist, and nine invalid/sensitivity tests pass. The agent-facing records
declare zero `LabelHand`, cached-target, or hidden-answer paths.

The separate label-based accuracy audit is construct validation, not part of
this task's answer and not an input available to the worker. The public thin
release requires users to hydrate the official Sen1Floods11 subset with the
checksum-verified installer documented in `ATTRIBUTIONS.md`.

**Validated contract.** Input isolation,
threshold method, nodata encoding, connectivity, areas, centroids, grid,
empty-mask policy, causal handles, schema, files, and all answers align.

---

# Question type 40 of 43 — Sen1Floods11 `B`

Population: **100 records** — 90 train and 10 public-reference test.

**Agent task.** Generate a run-scoped polygon GeoJSON from the SAR-derived
prediction and report generation status, polygon count, total and largest
component areas, largest bounding box/centroid, and the three most flooded 4×4
cells.

**Agent inference.** Polygons represent connected regions in the generated
prediction, not hand-label objects. Connectivity is 8-neighbour throughout;
switching to 4-neighbour would change every current scene. Reported area is the
exact-grid cell-area sum associated with the component, not an unqualified
planar area computed from longitude/latitude polygon coordinates.

**Benchmark meaning.** This tests causal raster-to-vector conversion,
connectivity semantics, run-scoped artifact creation, geometry validation,
largest-object characterization, deterministic spatial ranking, and combined
artifact-plus-numeric synthesis.

The only declared data path is `S1Portable.tif`. After `ReadData`,
`PrepareScene`, and `MapFlood`, `ExtractObjects(target=flood_polygons)` consumes
`flood_1`, writes the GeoJSON, and validates the feature count against the mask.
`DescribeFlood` consumes `objects_1`; `RankRegions` consumes `flood_report_1`
with `by=flood_percentage`, `candidates=grid_4x4`, and `top_k=3`, followed by
`TaskComplete`.

Polygonization uses rasterio feature extraction with connectivity 8 and source
georeferencing. Each feature receives a component ID. The largest component is
selected by positive pixel count; its bounding box uses outer pixel edges and
its centroid averages pixel centers. Grid ranking is descending flood
percentage, then flood-pixel count, then descending cell ID. The final key is
only a stable serialization rule, and numerical ties remain visible.

Independent artifact audit opens all B and E polygon outputs with zero
failures: feature counts match, every coordinate is finite, every geometry is
Polygon/MultiPolygon, and all coordinates lie within the source raster bounds.
The current Type B feature count ranges from 31 to 4,138 and GeoJSON size from
64,722 to 9,014,842 bytes. All 300 family ranking calls reproduce the expected
order; one Type B record exercises an equal percentage/pixel tie within its
top three. Four- and eight-neighbour counts differ in all 100 scenes, while
the reported counts match eight-neighbour results in 100/100. Focused execution
and complete answer evidence pass 100/100, and all 100 declared paths exist.

**Validated contract.** Prediction lineage, 8-neighbour
polygonization, geometry bounds, feature counts, exact-grid area semantics,
largest-object fields, ranking/ties, schema, files, and all answers align.

---

# Question type 41 of 43 — Sen1Floods11 `C`

Population: **100 records** — 90 train and 10 public-reference test.

**Agent task.** Derive the predicted mask, rank the three most flooded 4×4
cells, calculate maximum-cell concentration, and classify the prediction as
localized or dispersed under the declared threshold.

**Agent inference.** Concentration is a share of total predicted-flood pixels,
not the winning cell's within-cell flood percentage. `localized` means that a
single grid cell holds at least half of all predicted-flood pixels. An empty
prediction has concentration zero and is dispersed.

**Benchmark meaning.** This tests exact denominator selection, deterministic
grid aggregation and ranking, causal report-to-ranking dataflow, threshold
classification, visible tie handling, and zero-state interpretation.

The sole input is `S1Portable.tif`. `ReadData`, `PrepareScene` with a 4×4 grid
check, and `MapFlood` produce the current mask; `DescribeFlood` consumes it for
grid, concentration, and pattern metrics; `RankRegions` consumes
`flood_report_1` with `by=flood_percentage`, `candidates=grid_4x4`, and
`top_k=3`; then `TaskComplete` closes the specialist subgoal and ORC terminates
with the published answer reference.

Each deterministic index partition reports within-cell flood percentage and
share of total flood. Ranking is descending percentage, then flood pixels,
then descending cell ID; the ID key is stable serialization only, and tied
numbers remain in the answer. Concentration is
`max(cell flood pixels) / total predicted flood pixels`, with localized at
`>=0.5` and dispersed below it.

Independent checks reproduce all 100 full-grid totals, top-three lists,
concentrations, and classes with zero failures. Scores span 0.069474–0.673538.
Ninety-nine scenes are dispersed; the single localized scene belongs to the
test split. Thus training does not demonstrate the localized or empty-mask
branches, an intentional observed coverage limitation rather than a reason to
retune the threshold or split. Focused execution and complete answer evidence
pass 100/100, all 100 paths exist, and the worker rejects unsupported grid,
metric, candidate, and `top_k` contracts.

**Validated contract.** Grid
accounting, denominator, ranking/ties, concentration, threshold, zero policy,
causal handles, schema, files, and all answers align.

---

# Question type 42 of 43 — Sen1Floods11 `D`

Population: **100 records** — 90 train and 10 public-reference test.

**Agent task.** Generate the SAR prediction, compare its positive pixels with
the required JRC known-water raster, and report total predicted flood, overlap
and outside-reference counts/percentages, and largest-component area/centroid.

**Agent inference.** JRC is contextual known-water coverage, not flood ground
truth. A predicted pixel outside JRC is outside the known-water reference; it
must not automatically be called new or erroneous flood. Both percentages use
total predicted-flood pixels as denominator.

**Benchmark meaning.** This tests a causal two-source join, raster-grid
compatibility, boolean intersection, denominator discipline, zero-reference
handling, careful semantic wording, and structured multi-source synthesis.

Two required paths are declared: `S1Portable.tif` and `JRCWaterHand.tif`.
Separate `ReadData` calls feed
`PrepareScene(mode=sar_flood_reference)`, then `MapFlood` creates the current
prediction. `CompareSources(work=flood_1,reference=known_water,
criterion=overlap_vs_outside_reference)` validates and intersects the grids.
`DescribeFlood` consumes `compare_1` for prediction, component, overlap, and
outside-reference metrics, then `TaskComplete` closes the specialist subgoal
and ORC terminates with the published answer reference.

The worker requires identical array shape, CRS, and affine transform and
accepts only JRC values 0/1 (plus declared nodata if present). Overlap is
`prediction & JRC==1`; outside is `prediction & JRC!=1`. Counts partition the
predicted-flood pixels, and their percentages sum to 100 for nonempty masks.
A valid all-zero JRC raster is measured as zero known-water overlap, not
treated as absent data.

Independent reads reproduce every comparison with zero failures. All 100 grid,
CRS, transform, and encoding checks pass. Forty-two references contain known
water and yield positive overlap; 58 contain only valid zeros and yield exact
zero overlap. Overlap ranges from 0 to 76,295 pixels and 0–79.140461% of the
prediction; every overlap/outside count and percentage partitions correctly.
Focused execution and complete answer evidence pass 100/100, all 200 required
path references exist, and invalid/missing reference contracts are rejected.

**Validated contract.** Required inputs,
grid alignment, encoding, intersections, denominators, zero-reference state,
largest-component fields, cautious semantics, causal handles, schema, paths,
and all answers align.

---

# Question type 43 of 43 — Sen1Floods11 `E`

Population: **100 records** — 90 train and 10 public-reference test.

**Agent task.** Execute the complete SAR-flood analysis: generate the mask
and polygon artifacts, measure components/area/grid, rank cells, compare JRC
known-water context, and render a fresh analysis image. The runtime projects
the complete worker evidence into the fixed-schema result.

**Agent inference.** Each step must consume the current preceding handle; the
answer is not a static report lookup. The map visualizes the requested SAR,
prediction, component-boundary, and grid layers. JRC informs the numeric
comparison but is intentionally not drawn because the render request does not
enable that layer.

**Benchmark meaning.** This is the end-to-end capstone for raster processing,
raster-to-vector conversion, quantitative/spatial analysis, multi-source
comparison, ranking, deterministic visualization, artifact provenance, causal
tool use, and large structured-answer synthesis.

The two required paths are `S1Portable.tif` and `JRCWaterHand.tif`. The chain
calls `ReadData` for each input, `PrepareScene(mode=sar_flood_diagnostic)`,
`MapFlood`, `ExtractObjects(target=flood_polygons)`, `DescribeFlood`,
`RankRegions`, `CompareSources` from `rank_1`, and `RenderMap` from `compare_1`
with style `flood_diagnostic`; only then does `TaskComplete` close the
specialist subgoal. ORC terminates with the published reference to the
runtime-projected 19-field summary. The three generated artifacts are the
prediction GeoTIFF, polygon GeoJSON, and PNG/JSON render pair.

The returned summary combines all final contracts from Types A–D: predicted
coverage/area, 8-neighbour component and polygon counts, largest geometry,
full grid and top three, concentration/pattern, JRC overlap/outside partition,
method, and three generation flags. The renderer verifies its current handle,
requested/rendered layers, mask hash, component boundaries, changed pixels,
nonempty output, and `prepared_overlay_used=false`.

Persistent independent audit reports zero mask, geometry, grid, ranking,
known-water, render-contract, or render-artifact failures. All 100 PNGs and
manifests open; images are 512×512, 69,088–636,031 bytes, change
3,714–178,679 pixels from the SAR base, and contain 682–79,742 component-boundary
pixels. Both prediction-mask and image SHA-256 values reproduce in 100/100
separate executions. Focused execution and complete answer evidence pass
100/100, all 200 required path references exist, and all nine worker
argument/sensitivity tests pass.

**Validated contract.** Every input, intermediate handle,
measurement, polygon, grid/rank, contextual comparison, render, artifact,
schema field, path, and expected answer is aligned end to end.

---

All **43 of 43 question types** are defined by the contracts above. The release
baseline includes the repository-wide replay, deep asset inspection,
derivative consistency checks, and documentation consistency checks.